Apa itu anotasi:
Anotasi (anotasi) adalah cara dan metode yang disediakan oleh Java untuk mengaitkan informasi dan metadata (metadata) apa pun dengan elemen dalam metaprogram. Anotasi (anotasi) adalah sebuah antarmuka. Program dapat memperoleh objek Anotasi dari elemen program yang ditentukan melalui refleksi, dan kemudian memperoleh metadata dalam anotasi melalui objek Anotasi.
Anotasi (anotasi) diperkenalkan di JDK5.0 dan versi yang lebih baru. Ini dapat digunakan untuk membuat dokumentasi, melacak dependensi dalam kode Anda, dan bahkan melakukan pemeriksaan dasar pada waktu kompilasi. Dalam beberapa hal, anotasi digunakan seperti pengubah dan diterapkan pada deklarasi paket, tipe, konstruktor, metode, variabel anggota, parameter, dan variabel lokal. Informasi ini disimpan dalam pasangan struktur Anotasi "nama=nilai".
Anggota Anotasi dideklarasikan sebagai metode tanpa parameter dalam tipe Anotasi. Nama metode dan nilai kembaliannya menentukan nama dan tipe anggota. Ada sintaks default khusus di sini: diperbolehkan untuk mendeklarasikan nilai default anggota Anotasi mana pun: Anotasi dapat menggunakan pasangan nama=nilai sebagai nilai anggota Anotasi yang tidak menentukan nilai default =pasangan nilai juga dapat digunakan untuk mengganti nilai default nilai anggota lainnya. Ini agak mirip dengan karakteristik pewarisan kelas. Konstruktor kelas induk dapat digunakan sebagai konstruktor default subkelas, tetapi juga dapat ditimpa oleh subkelas.
Anotasi dapat digunakan untuk mengaitkan informasi apa pun dengan elemen program (kelas, metode, variabel anggota, dll.). Perlu dicatat bahwa ada aturan dasar di sini: Anotasi tidak dapat mempengaruhi eksekusi kode program, tidak peduli apakah anotasi ditambahkan atau dihapus, kode akan dieksekusi secara konsisten. Selain itu, meskipun beberapa anotasi diakses saat runtime melalui metode API refleksi Java, penerjemah bahasa Java mengabaikan anotasi ini saat bekerja. Justru karena mesin virtual Java mengabaikan Anotasi maka jenis anotasi "tidak berfungsi" dalam kode; informasi dalam jenis anotasi hanya dapat diakses dan diproses melalui beberapa alat pendukung. Artikel ini akan membahas tipe Anotasi standar dan meta-anotasi. Alat yang menyertai tipe anotasi ini adalah kompiler Java (yang tentu saja menanganinya dengan cara khusus).
--------------------------------------------------- -----------------------------------
Apa itu metadata (metadata):
Metadata diterjemahkan dari kata metadata yang berarti “data tentang data”.
Metadata memiliki banyak fungsi. Misalnya, Anda mungkin menggunakan komentar Javadoc untuk menghasilkan dokumentasi secara otomatis. Ini adalah salah satu jenis fungsi metadata. Secara umum, metadata dapat digunakan untuk membuat dokumentasi, melacak ketergantungan kode, melakukan pemeriksaan format waktu kompilasi, dan mengganti file konfigurasi yang ada. Jika kita ingin mengklasifikasikan peran metadata, saat ini belum ada definisi yang jelas, namun secara kasar kita dapat membaginya menjadi tiga kategori berdasarkan perannya:
1. Menulis dokumen: Menghasilkan dokumen melalui metadata yang diidentifikasi dalam kode 2. Analisis kode: Menganalisis kode melalui metadata yang diidentifikasi dalam kode 3. Pemeriksaan kompilasi: Dengan menggunakan metadata yang diidentifikasi dalam kode, kompiler dapat mencapai kompilasi dasar Periksa apakah metadata di Java ada dalam kode Java dalam bentuk tag. Keberadaan tag metadata tidak mempengaruhi kompilasi dan eksekusi kode program. Ini hanya digunakan untuk menghasilkan file lain atau untuk mengetahui kode yang dijalankan saat runtime informasi.
Singkatnya:
Pertama, metadata ada dalam kode Java dalam bentuk tag.
Kedua, informasi yang dijelaskan oleh metadata bersifat aman untuk tipe, yaitu bidang dalam metadata memiliki tipe yang jelas.
Ketiga, metadata memerlukan pemrosesan tambahan dengan alat selain kompiler yang digunakan untuk menghasilkan komponen program lainnya.
Keempat, metadata hanya bisa ada di tingkat kode sumber Java, atau bisa ada di dalam file Kelas yang dikompilasi.
--------------------------------------------------- -----------------------------------
Jenis Anotasi dan Anotasi:
Anotasi:
Anotasi menggunakan sintaks baru yang dibawa dalam java5.0, dan perilakunya sangat mirip dengan pengubah seperti public dan final. Setiap Anotasi memiliki nama dan jumlah anggota >=0. Setiap anggota Anotasi memiliki nama dan nilai yang disebut pasangan nama=nilai (seperti javabean), dan nama=nilai memuat informasi Anotasi.
Jenis anotasi:
Tipe Anotasi menentukan nama, tipe, dan nilai default anggota Anotasi. Tipe Anotasi dapat dikatakan sebagai antarmuka Java khusus. Variabel anggotanya dibatasi, dan sintaks baru diperlukan saat mendeklarasikan tipe Anotasi. Saat kita mengakses Anotasi melalui API refleksi Java, nilai yang dikembalikan akan menjadi objek yang mengimplementasikan antarmuka tipe anotasi. Dengan mengakses objek ini, kita dapat dengan mudah mengakses anggota Anotasinya. Bab berikut akan menyebutkan tiga tipe Anotasi standar yang disertakan dalam paket java.lang java5.0.
--------------------------------------------------- -----------------------------------
Kategori anotasi:
Berdasarkan jumlah parameter anotasi, kita dapat membagi anotasi menjadi tiga kategori:
1. Anotasi tanda: Jenis Anotasi tanpa definisi anggota disebut anotasi tanda. Jenis Anotasi ini hanya menggunakan ada atau tidaknya dirinya sendiri untuk memberikan informasi kepada kami. Misalnya, anotasi sistem berikut @Override;
2. Anotasi nilai tunggal 3. Anotasi lengkap
Menurut penggunaan dan tujuan anotasi, kita dapat membagi Anotasi menjadi tiga kategori:
1. Anotasi sistem bawaan JDK 2. Anotasi meta 3. Anotasi khusus
--------------------------------------------------- -----------------------------------
Anotasi standar bawaan sistem:
Sintaks anotasi relatif sederhana, kecuali penggunaan simbol @, pada dasarnya konsisten dengan sintaks bawaan Java. Ada tiga anotasi standar yang dibangun dalam JavaSE, yang didefinisikan di java.lang:
@Override: Digunakan untuk memodifikasi metode ini untuk mengganti metode kelas induk;
@Tidak digunakan lagi: digunakan untuk mengubah metode yang sudah usang;
@SuppressWarnings: Digunakan untuk memberi tahu kompiler Java untuk menyembunyikan peringatan kompilasi tertentu.
Mari kita lihat fungsi dan skenario penggunaan ketiga anotasi standar bawaan secara bergantian.
--------------------------------------------------- -----------------------------------
@Override, batasi penggantian metode kelas induk:
@Override adalah jenis anotasi penanda yang digunakan untuk memberi anotasi pada metode. Hal ini menunjukkan bahwa metode beranotasi membebani metode kelas induk dan memainkan peran penegasan. Jika kita menggunakan Anotasi semacam ini dalam metode yang tidak mengesampingkan metode kelas induk, kompiler Java akan memperingatkan Anda tentang kesalahan kompilasi. Anotasi ini sering kali muncul ketika kita mencoba mengganti metode kelas induk tetapi menulis nama metode yang salah. Penggunaannya sangat sederhana: saat menggunakan anotasi ini, cukup tambahkan @Override di depan metode yang dimodifikasi. Kode berikut adalah contoh penggunaan @Override untuk memodifikasi metode displayName() dalam upaya mengganti kelas induk, namun terdapat kesalahan ejaan:
kekosongan publik nama tampilan(){
System.out.println("Nama buahnya adalah: *****");
}
}
kelas Jeruk meluas Buah {
@Mengesampingkan
kekosongan publik nama tampilan(){
System.out.println("Nama buahnya: jeruk");
}
}
kelas Apple memperluas Buah {
@Mengesampingkan
nama tampilan kekosongan publik(){
System.out.println("Nama buahnya : Apel");
}
}
@Tidak digunakan lagi, tag tidak digunakan lagi:
Demikian pula, Deprecated juga merupakan anotasi markup. Ketika suatu tipe atau anggota tipe didekorasi dengan @Deprecated, kompiler akan melarang penggunaan elemen program yang dianotasi ini. Dan modifikasi semacam ini memiliki tingkat "kontinuitas" tertentu: jika kita menggunakan tipe atau anggota yang sudah ketinggalan zaman ini dalam kode melalui pewarisan atau penimpaan, meskipun tipe atau anggota yang diwarisi atau ditimpa tidak dinyatakan sebagai @Tidak Digunakan Lagi, Kompiler masih harus memperingatkan Anda.
Perlu dicatat bahwa ada perbedaan antara tipe anotasi @Deprecated dan tag @deprecated di javadoc: yang pertama dikenali oleh kompiler java, sedangkan yang kedua dikenali oleh alat javadoc dan digunakan untuk menghasilkan dokumentasi (termasuk alasan program anggota sudah usang, dan uraiannya tentang bagaimana harus dilarang atau diganti).
Di Java 5.0, kompiler Java masih mencari tag Javadoc @deprecated dan menggunakannya untuk menghasilkan pesan peringatan seperti pada versi sebelumnya. Namun situasi ini akan berubah di versi berikutnya, dan kita harus mulai menggunakan @Deprecated sekarang untuk mendekorasi metode yang tidak digunakan lagi, bukan tag javadoc @deprecated.
Dalam program berikut, anotasi @Deprecated digunakan untuk menandai metode sebagai kedaluwarsa. Pada saat yang sama, tag @deprecated digunakan dalam anotasi metode untuk menandai metode sebagai kedaluwarsa.
/**
* @deprecated Metode ini telah kedaluwarsa dan tidak disarankan.
*/
@Tidak digunakan lagi
kekosongan publik showTaste(){
System.out.println("Rasa buah apel: renyah dan manis");
}
public void showTaste(int typeId){
jika(tipeId==1){
System.out.println("Rasa buah apel : asam");
}
lain jika(typeId==2){
System.out.println("Rasa buah apel: manis");
}
kalau tidak{
System.out.println("Rasa buah apel: renyah dan manis");
}
}
}
kelas publik FruitRun {
/**
* @param argumen
*/
public static void main(String[] args) {
Apel apel=Apel baru();
apel.namatampilan();
AppleService appleService=AppleServicebaru();
appleService.showTaste();
appleService.showTaste(0);
appleService.showTaste(2);
}
}
--------------------------------------------------- -----------------------------------
SuppressWarnings, sembunyikan peringatan kompiler:
@SuppressWarnings digunakan untuk mematikan peringatan kompiler secara selektif untuk kelas, metode, variabel anggota, dan inisialisasi variabel. Di java5.0, kompiler javac yang disediakan oleh sun memberi kita opsi -Xlint untuk memungkinkan kompiler memperingatkan terhadap kode program legal. Misalnya, ketika kita menggunakan kelas koleksi generik tanpa memberikan tipenya, kompiler akan memunculkan peringatan "peringatan tidak dicentang". Biasanya jika hal ini terjadi, kita perlu mencari kode yang menyebabkan peringatan tersebut. Jika ini benar-benar merupakan kesalahan, kita perlu memperbaikinya. Misalnya, jika pesan peringatan menunjukkan bahwa pernyataan switch dalam kode kita tidak mencakup semua kemungkinan kasus, maka kita harus menambahkan kasus default untuk menghindari peringatan ini.
Terkadang kita tidak dapat menghindari peringatan ini. Misalnya, kita tidak dapat menghindari peringatan yang tidak dicentang ini ketika kita menggunakan kelas koleksi generik yang harus berinteraksi dengan kode lama non-generik. @SuppressWarning akan berguna saat ini. Tambahkan modifikasi @SuppressWarnings sebelum metode yang dipanggil untuk memberi tahu kompiler agar berhenti memperingatkan tentang metode ini.
SuppressWarning bukan anotasi markup. Ia memiliki anggota bertipe String[], nilai anggota ini adalah nama peringatan terlarang. Untuk kompiler javac, nama peringatan yang valid untuk opsi -Xlint juga valid untuk @SuppressWarings, dan kompiler mengabaikan nama peringatan yang tidak dikenal.
Sintaks anotasi memungkinkan nama anotasi diikuti dengan tanda kurung. Di dalam tanda kurung terdapat pasangan nama=nilai yang dipisahkan koma yang digunakan untuk memberikan nilai kepada anggota anotasi. Contohnya adalah sebagai berikut:
@SuppressWarnings(nilai={ "tipe mentah", "tidak dicentang" })
Daftar statis publik<Buah> getFruitList(){
Daftar<Buah> daftar buah=Daftar Array baru();
kembalikan Daftar buah;
}
@SuppressWarnings({ "tipe mentah", "tidak dicentang" })
Daftar statis publik<Buah> getFruit(){
Daftar<Buah> daftar buah=Daftar Array baru();
kembalikan Daftar buah;
}
@SuppressWarnings("tidak digunakan")
public static void main(String[] args){
Daftar<String> strList=Daftar Arraybaru<String>();
}
}
Deskripsi singkat tentang nilai parameter umum yang dijelaskan oleh SuppressWarnings:
1.penghentian: Peringatan ketika kelas atau metode yang tidak digunakan lagi digunakan;
2. tidak dicentang: Peringatan ketika konversi yang tidak dicentang dilakukan, misalnya saat menggunakan koleksi, obat generik tidak digunakan untuk menentukan jenis koleksi yang disimpan;
3.fallthrough: Peringatan ketika blok program Switch mengarah langsung ke situasi berikutnya tanpa Break;
4.path: Peringatan ketika tidak ada jalur di jalur kelas, jalur file sumber, dll.;
5.serial: Peringatan ketika definisi serialVersionUID tidak ada pada kelas serializable;
6.finally: Peringatan ketika klausa akhirnya tidak dapat diselesaikan secara normal;
7.all: Peringatan tentang semua situasi di atas.