Menggunakan Kaedah dan Pemegang Pembolehubah dalam Java untuk Akses dan Manipulasi Objek Masa Jalan

Pengendalian refleksi dan kaedah/var ialah dua ciri berkuasa dalam Java yang membolehkan pembangun mengakses dan memanipulasi objek pada masa jalan. Walau bagaimanapun, mereka berbeza dalam cara mereka mengakses dan mengendalikan objek.

Mari kita lihat contoh cara menggunakan refleksi untuk mengakses kaedah dalam kelas. Kita akan mulakan dengan kelas ringkas yang dipanggil "MyClass" yang mempunyai pembolehubah rentetan peribadi dan kaedah pengambil untuk pembolehubah itu. Untuk mencipta objek ini, kita boleh menggunakan instantiasi biasa:

MyClass objectInstance = new MyClass("John Doe");

Untuk mengakses kaedah menggunakan refleksi, kita perlu terlebih dahulu mendapatkan kelas contoh objek kita menggunakan kaedah getClass(). Kemudian, kita boleh menggunakan kaedah getDeclaredMethod() untuk mencari kaedah yang ingin kita akses, dalam kes ini, "getName". Akhir sekali, kita perlu menggunakan kaedah menggunakan kaedah invoke() dan lulus dalam contoh objek kita. Berikut ialah kod untuk proses ini:

Class<?> clazz = objectInstance.getClass();
Method method = clazz.getDeclaredMethod("getName");
String value = (String) method.invoke(objectInstance);
System.out.println(value); // prints "John Doe"

Sebaliknya, pengendalian kaedah, yang terdapat dalam kelas MethodHandles, menyediakan cara yang lebih selamat dan lebih optimum untuk mengakses kaedah. Ini kerana ia direka khusus untuk tujuan ini dan dipertingkatkan untuk pengoptimuman JVM.

Menggunakan pemegang kaedah untuk mengakses kaedah adalah serupa dengan menggunakan pantulan. Kami mulakan dengan mendapatkan kelas contoh objek kami. Kemudian, kami menggunakan kaedah findVirtual() pada MethodHandles untuk mencari kaedah yang ingin kami akses. Seterusnya, kami memanggil kaedah menggunakan kaedah invoke() dan lulus dalam contoh objek kami. Berikut ialah kod untuk proses ini:

Class<?> clazz = objectInstance.getClass();
MethodHandle handle = MethodHandles.lookup().findVirtual(clazz, "getName", methodType(String.class));
String value = (String) handle.invoke(objectInstance);
System.out.println(value);  // Prints “John Doe”

Walau bagaimanapun, terdapat had kepada kaedah yang boleh dilakukan oleh pengendalian. Mereka tidak boleh mengendalikan tugas seperti membuat kelas instantiate, yang boleh dilakukan dengan refleksi.

Untuk mempamerkan kuasa pengendalian kaedah, mari kita lihat cara ia boleh digunakan untuk mengakses terus medan peribadi dalam kelas. Katakan kelas "MyClass" kami mempunyai pembolehubah rentetan peribadi yang dipanggil "nama". Kita boleh menggunakan refleksi untuk mengaksesnya, tetapi menggunakan pemegang kaedah ialah alternatif yang lebih selamat.

Untuk mengakses terus medan peribadi menggunakan pantulan, kita perlu mendapatkan kelas contoh objek kita terlebih dahulu. Kemudian, kami menggunakan kaedah getDeclaredField() untuk mencari medan yang ingin kami akses, dalam kes ini, "nama". Walau bagaimanapun, memandangkan medan ini adalah peribadi, kita perlu menggunakan kaedah setAccessible() untuk menetapkan kebolehaksesannya kepada benar. Akhir sekali, kita boleh menggunakan kaedah get() untuk mendapatkan semula nilai medan. Berikut ialah kod untuk proses ini:

Class<?> clazz = objectInstance.getClass(); 
Field field = clazz.getDeclaredField("name"); 
field.setAccessible(true); 
String value = (String) field.get(objectInstance);
System.out.println(value); // prints “John Doe”

Menggunakan pemegang kaedah, prosesnya adalah serupa. Kami mulakan dengan mendapatkan kelas contoh objek kami, dan kemudian kami menggunakan kaedah privateLookupIn() pada MethodHandles untuk menghormati pengubah akses medan (kerana ia peribadi). Seterusnya, kami menggunakan kaedah findVarHandle() untuk mencari medan yang ingin kami akses. Akhir sekali, kita boleh menggunakan kaedah get() untuk mendapatkan semula nilainya. Berikut ialah kod untuk proses ini:

Class<?> clazz = objectInstance.getClass(); 
VarHandle handle = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()).findVarHandle(clazz, "name", String.class);
String value = (String) handle.get(objectInstance);
System.out.println(value); // prints “John Doe”

Adalah disyorkan untuk membuat seketika pemegang secara statik atas sebab prestasi, tetapi ini memerlukan mengetahui nama kelas. Jika anda tidak tahu nama kelas, pendekatan ini tidak boleh digunakan.

Satu had pengendalian kaedah ialah ia tidak menyediakan cara untuk mengendalikan pengecualian yang diperiksa. Pelbagai operasi pada pemegang kaedah dan pemegang var membuang pengecualian yang diperiksa yang mesti ditangkap dan diisytiharkan dalam kod pengeluaran.

Kesimpulannya, kaedah dan pemegang pembolehubah menyediakan julat keupayaan terfokus dalam JDK untuk mencari metadata kelas dan mengakses kaedah dan medan di luar sekatan Java biasa. Walaupun mereka tidak merangkumi semua keupayaan refleksi, mereka menawarkan alternatif yang lebih selamat dan lebih optimum untuk tugasan ini.

Alami cara terbaik untuk belajar untuk Pensijilan Java dengan Rancangan Kajian MyExamCloud dan nikmati ujian amalan percuma.

Atas ialah kandungan terperinci Menggunakan Kaedah dan Pemegang Pembolehubah dalam Java untuk Akses dan Manipulasi Objek Masa Jalan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!