Saat saya pertama kali belajar Java, sangat sulit memahami apa itu refleksi.
Beberapa buku, bahkan yang sangat klasik, menjelaskan berbagai hal dengan cara yang membuat orang merasa bingung.
Selain itu, dikatakan secara online bahwa mekanisme refleksi perlu sering digunakan ketika mempelajari kerangka kerja di masa depan, yang selalu membuat orang merasa sedikit tidak nyaman.
Saya baru saja secara tidak sengaja menonton beberapa bab dan video yang menjelaskan refleksi, dan saya rasa saya dapat memahaminya sedikit lebih baik.
Sekarang saya memutuskan untuk bekerja keras, membaca dan menulis pada saat yang sama, dan mencatat beberapa konten dan operasi utama di sini.
Menurutku, bagi orang bodoh sepertiku, mungkin cara terbaik untuk belajar adalah dengan mengulang
Ketika saya menemukan sesuatu yang saya tidak mengerti, saya berhenti dan mempelajarinya lagi. Meskipun itu membuang banyak waktu, hal itu juga mempunyai pengaruh pada saya.
Pemahaman saya adalah: apa yang disebut refleksi adalah mengembalikan informasi lengkap kelas berdasarkan objek yang sudah dipakai.
Setidaknya bagi saya, menurut saya manfaatnya adalah memungkinkan saya memahami berorientasi objek dari bawah ke atas.
x_x Di sini aku benci kepala tebal itu lagi, mereka membunuh semua sel otakku.
Kelas kelasJika Anda ingin menyelesaikan refleksi, Anda harus memahami kelas Kelas
Contoh 1: Dapatkan nama paket dan nama kelas melalui objektes kelas {
}
Demo kelas publik {
public static void main(String[] args) {
Tes t = Tes baru();
Sistem.keluar.println(t.getClass());
Sistem.keluar.println(t.getClass().getName());
}
}
Hasil kompilasinya seperti berikut, perhatikan saja cara kompilasi paketnya.
Metode getClass() di sini diwarisi dari kelas Object secara default.
Di Java, kelas Object adalah kelas induk dari semua kelas. Demikian pula, objek yang dipakai di semua kelas juga merupakan turunan dari kelas Kelas.
Oleh karena itu, hal ini akan melibatkan konsep transformasi ke atas dan transformasi ke bawah
Obat generik juga akan mengikuti di sini karena ketidakamanan dari gips ke bawah.
(Tapi yang ingin saya katakan adalah desain generik di sini sangat mempesona! Sial, desain sintaksis seluruh Java juga mempesona, sangat menjijikkan!!!)
Contoh 2: Instansiasi kelas KelasKarena kelas Class tidak memiliki konstruktor, cara untuk membuat instance kelas Class agak istimewa. Ada tiga cara:
Objek.getClass()}
Demo kelas publik {
public static void main(String[] args) {
//Metode 1:
Tes t = Tes baru();
Kelas<?meluas Tes> c1 = t.getClass();
Sistem.keluar.println(c1);
//Metode 2:
//Untuk menghindari kekhususan, kelas Test tidak digunakan di sini, tetapi kelas String di perpustakaan Java digunakan.
Kelas<String> c2 = String.kelas;
Sistem.keluar.println(c2);
//Metode 3:
//forName() metode akan memunculkan pengecualian
Kelas<?> c3 = nol;
mencoba {
c3 = Kelas.forName("Tes");
} tangkapan (ClassNotFoundException e) {
e.printStackTrace();
}
Sistem.keluar.println(c3);
}
}
Ada metode di kelas Kelas yang disebut newInstance(), yang dapat digunakan untuk membuat instance baru dari objek kelas Kelas
Bagaimana cara mengatakannya? Konten yang terkandung dalam objek Kelas adalah kelas yang direfleksikan. Kita perlu membuat instance baru (objek baru) dari kelas tersebut.
Contoh 3: Membangun objek tanpa parameter kelas Class //Hasilkan referensi ke sebuah string
String s = nol;
mencoba {
//Downcast objek yang dibangun ke kelas String
//metode newInstance() akan memunculkan pengecualian
s = (String) c.newInstance();
} tangkapan (InstantiationException e) {
e.printStackTrace();
} tangkapan (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println("Panjang string: " + s.panjang());
}
}
Ini membuat objek baru dalam bentuk tanpa parameter, seperti dalam mode normal
Membangun objek baru melalui konstruktor tanpa argumen sama dengan
Kita tahu bahwa selain konstruktor tanpa parameter, ada juga konstruktor berparameter di sebuah kelas.
Lalu bagaimana cara mengkonstruksi objek berupa parameter dalam refleksi? Baca terus
Contoh 4: Objek yang dibangun dengan parameter dari kelas Kelas Demo kelas publik {
//Metode berikut memunculkan terlalu banyak pengecualian. Demi kekompakan kode, metode tersebut dilemparkan langsung ke mesin virtual di sini.
public static void main(String[] args) melempar Pengecualian {
Kelas<?> c = nol;
mencoba {
c = Kelas.forName("java.lang.String");
} tangkapan (ClassNotFoundException e) {
e.printStackTrace();
}
karakter[] ch = {'h','e','l','l','o'};
String s = nol;
//Dapatkan konstruktor berparameter dari objek Kelas. Parameter dalam tanda kurung ditulis sebagai: type.class
Konstruktor<?> con = c.getConstructor(char[].class);
//Gunakan metode konstruksi ini untuk membuat objek string baru, parameternya adalah array char
s = (String) con.newInstance(ch);
System.out.println("String yang dibuat: " + s);
}
}
Kita masih menggunakan kelas String sebagai contoh, karena kelas String lebih sering digunakan dan lebih mudah dipahami.
Yang perlu diperhatikan disini adalah konstruktor perlu diperoleh dengan menggunakan metode getConstructor()
Adapun tipe parameternya adalah: tipe asli.kelas
Poin lainnya adalah apakah memiliki parameter atau tanpa parameter, metode konstruksi yang digunakan di sini harus ada di kelas aslinya.
Lantas, bagaimana kita bisa mengetahui informasi detail seperti metode konstruktor, metode biasa, kelas induk yang diwarisi, dan sebagainya di kelas aslinya? Baca terus
Dapatkan struktur kelasnyaUntuk mendapatkan struktur kelas melalui refleksi, kita perlu mengimpor paket baru java.lang.reflect
Contoh 5: Dapatkan konstruktor suatu kelas Demo kelas publik {
//Metode berikut memunculkan terlalu banyak pengecualian. Demi kekompakan kode, metode tersebut dilemparkan langsung ke mesin virtual di sini.
public static void main(String[] args) melempar Pengecualian {
Kelas<?> c = nol;
mencoba {
c = Kelas.forName("java.lang.Boolean");
} tangkapan (ClassNotFoundException e) {
e.printStackTrace();
}
//Metode getConstructors() di sini mengembalikan array Konstruktor
Konstruktor<?>[] kontra = c.getConstructors();
//Anda dapat menulis sendiri metode pencetakannya. Untuk kenyamanan, saya menggunakan Arrays.toString() untuk melakukannya.
System.out.println(Arrays.toString(kontra));
}
}
Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
Kelas<?> c = nol;
mencoba {
c = Kelas.forName("java.lang.Boolean");
} tangkapan (ClassNotFoundException e) {
e.printStackTrace();
}
Kelas<?>[] di = c.getInterfaces();
System.out.println(Arrays.toString(in));
}
}
Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
Kelas<?> c = nol;
mencoba {
c = Kelas.forName("java.lang.Boolean");
} tangkapan (ClassNotFoundException e) {
e.printStackTrace();
}
Metode[] m = c.getMethods();
//Oke, kali ini saya akan berbelas kasihan dan menulis daftar printout.
for (int i = 0; i < m.panjang; i++) {
Sistem.keluar.println(m[i]);
}
}
}
kelas Orang {
nama String pribadi;
usia swasta;
}
Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
Kelas<?> c = nol;
mencoba {
c = Kelas.forName("Orang");
} tangkapan (ClassNotFoundException e) {
e.printStackTrace();
}
Bidang[] f = c.getDeclaredFields();
for (int i = 0; i < f.panjang; i++) {
Sistem.keluar.println(f[i]);
}
}
}
Metode getDeclaredFielsd() bisa mendapatkan semua properti, dan getFields() hanya bisa mendapatkan properti publik.
Contoh 10: Dapatkan nilai atribut di kelas ini kelas Orang {
nama String publik;
usia swasta;
Orang publik(String nama, int umur) {
ini.nama = nama;
this.usia = usia;
}
}
Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
Orang p = Orang baru("zhangsan",12);
Kelas<?> c = p.getClass();
//Dapatkan nilai atribut publik
Bidang f1 = c.getField("nama");
//get(p) menunjukkan nilai objek mana yang ingin diperoleh
String str = (String) f1.get(p);
System.out.println("Nama: " + str);
//Dapatkan nilai atribut privat
Bidang f2 = c.getDeclaredField("usia");
//age adalah milik pribadi, jadi atur pemeriksaan keamanan ke true
f2.setAccessible(benar);
int umur = (int) f2.get(p);
System.out.println("Umur : " + umur);
}
}
Terus terang, saya belum menemukan ilmu apa pun di Java yang bisa membutakan mata titanium saya.
Setiap kali, saya harus menulis banyak sintaks yang membosankan untuk mengimplementasikan gadget, atau saya harus memanggil API dengan putus asa dan memberikan pengecualian dengan putus asa.
Membuat kode yang tidak cukup ringkas menjadi rumit
Jika saya menyukai suatu bahasa, karakteristiknya harus membuat saya terkesan sebelum saya dapat menggunakannya untuk membuat sesuatu.
Jelas Java tidak membuat saya senang. Mungkin banyak programmer seperti saya yang terpaksa menggunakan Java.
Hanya untuk menenangkan hati coding saya yang kesepian, baca terus di bawah
Contoh Penerapan Refleksi 11: Memodifikasi atribut melalui refleksi kelas Orang {
nama String pribadi;
Orang Publik (Nama string) {
ini.nama = nama;
}
String publik keString() {
return "Nama: " + ini.nama;
}
}
Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
Orang p = Orang baru("王二狗");
Sistem.keluar.println(p);
Kelas<?> c = p.getClass();
//Tentukan properti yang akan diubah
Bidang f = c.getDeclaredField("nama");
f.setAccessible(benar);
//Ubah properti dan teruskan objek dan nilai yang akan ditetapkan
f.set(p, "Zhang Erdan");
Sistem.keluar.println(p);
}
}
kelas Orang {
pencetakan kekosongan publik(int i) {
System.out.println("Saya menulis angka: " + i);
}
public static void say(String str) {
System.out.println("Saya berkata: "+str);
}
}
Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
Orang p = Orang baru();
Kelas<?> c = p.getClass();
//getMethod() metode harus memasukkan nama metode dan tipe parameter
Metode m1 = c.getMethod("print", int.class);
//invoke() berarti memanggil dan perlu meneruskan objek dan parameter
m1.memanggil(hal, 10);
Metode m2 = c.getMethod("say", String.class);
//Nol di sini berarti tidak dipanggil oleh objek, yaitu metode statis
m2.invoke(null, "adikmu");
}
}
Berikut adalah demonstrasi metode parameter normal dan metode statis
Sekarang semua parameter telah dituliskan, parameter tanpa parameter menjadi lebih sederhana. Cukup masukkan objek secara langsung.
Contoh 13: Memanipulasi array melalui refleksi Demo kelas publik {
public static void main(String[] args) melempar Pengecualian {
int[] arr = {1,2,3,4,5};
Kelas<?> c = arr.getClass().getComponentType();
System.out.println("Jenis array: " + c.getName());
int len = Array.getLength(arr);
System.out.println("Panjang array: " + len);
System.out.print("Melintasi array: ");
untuk (int saya = 0; saya < len; saya++) {
Sistem.keluar.cetak(Array.get(arr, i) + " ");
}
Sistem.keluar.println();
//modifikasi array
System.out.println("Elemen pertama sebelum modifikasi: " + Array.get(arr, 0));
Array.set(arr, 0, 3);
System.out.println("Elemen pertama yang dimodifikasi: " + Array.get(arr, 0));
}
}
Itu saja untuk saat ini. Buku yang saya baca juga mencakup penerapan refleksi dalam mode pabrik.
Tidak lebih dari menggantinya dengan metode forName().
Saya seorang pemula di Java. Saya benci sintaksis dan desain Java yang menjijikkan.
Ini semua demi Android, untuk meletakkan fondasi, dan beradaptasi dengan pekerjaan di masa depan.