java
Dalam tutorial ini, kita akan mempelajari refleksi, sebuah fitur dalam pemrograman Java yang memungkinkan kita untuk memeriksa dan memodifikasi kelas, metode, dll.
Di Java, refleksi memungkinkan kita untuk memeriksa dan memanipulasi kelas, antarmuka, konstruktor, metode, dan bidang pada saat dijalankan.
Ada kelas di Java bernama Class
yang menyimpan semua informasi tentang objek dan kelas saat runtime. Objek Kelas dapat digunakan untuk melakukan refleksi.
Untuk mencerminkan kelas Java, pertama-tama kita perlu membuat objek Kelas .
Dan, dengan menggunakan objek, kita dapat memanggil berbagai metode untuk mendapatkan informasi tentang metode, bidang, dan konstruktor yang ada di kelas.
Ada tiga cara untuk membuat objek Kelas:
1. Menggunakan metode forName()
class Dog {...}
// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");
Di sini, forName()
metode mengambil nama kelas untuk direfleksikan sebagai argumennya.
2. Menggunakan metode getClass()
// create an object of Dog class
Dog d1 = new Dog();
// create an object of Class
// to reflect Dog
Class b = d1.getClass();
Di sini, kita menggunakan objek Anjing class untuk membuat objek Class .
3. Menggunakan .ekstensi kelas
// create an object of Class
// to reflect the Dog class
Class c = Dog.class;
Sekarang kita tahu bagaimana kita bisa membuat objek dari Class
. Kita dapat menggunakan objek ini untuk mendapatkan informasi tentang kelas yang sesuai saat runtime.
import java.lang.Class;
import java.lang.reflect.*;
class Animal {
}
// put this class in different Dog.java file
public class Dog extends Animal {
public void display() {
System.out.println("I am a dog.");
}
}
// put this in Main.java file
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// get name of the class
String name = obj.getName();
System.out.println("Name: " + name);
// get the access modifier of the class
int modifier = obj.getModifiers();
// convert the access modifier to string
String mod = Modifier.toString(modifier);
System.out.println("Modifier: " + mod);
// get the superclass of Dog
Class superClass = obj.getSuperclass();
System.out.println("Superclass: " + superClass.getName());
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Keluaran
Name: Dog Modifier: public Superclass: Animal
Pada contoh di atas, kita telah membuat superclass:Animal dan subkelas:Anjing . Di sini, kami mencoba memeriksa kelas Anjing .
Perhatikan pernyataannya,
Class obj = d1.getClass();
Di sini, kita membuat objek obj dari Kelas menggunakan getClass()
metode. Menggunakan objek, kita memanggil metode yang berbeda dari Class .
Untuk mempelajari lebih lanjut tentang Class
, kunjungi Java Class (dokumentasi resmi Java).
Catatan :Kami menggunakan Modifier
class untuk mengonversi pengubah akses integer menjadi string.
Paket java.lang.reflect
menyediakan kelas yang dapat digunakan untuk memanipulasi anggota kelas. Misalnya,
Method
class menyediakan berbagai metode yang dapat digunakan untuk mendapatkan informasi tentang metode yang ada dalam suatu kelas. Misalnya,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
// methods of the class
public void display() {
System.out.println("I am a dog.");
}
private void makeSound() {
System.out.println("Bark Bark");
}
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// using object of Class to
// get all the declared methods of Dog
Method[] methods = obj.getDeclaredMethods();
// create an object of the Method class
for (Method m : methods) {
// get names of methods
System.out.println("Method Name: " + m.getName());
// get the access modifier of methods
int modifier = m.getModifiers();
System.out.println("Modifier: " + Modifier.toString(modifier));
// get the return types of method
System.out.println("Return Types: " + m.getReturnType());
System.out.println(" ");
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Keluaran
Method Name: display Modifier: public Return Types: void Method Name: makeSound Modifier: private Return Types: void
Dalam contoh di atas, kami mencoba untuk mendapatkan informasi tentang metode yang ada di Anjing kelas. Seperti disebutkan sebelumnya, pertama-tama kita membuat objek obj dari Class
menggunakan getClass()
metode.
Perhatikan ekspresinya,
Method[] methods = obj.getDeclaredMethod();
Di sini, getDeclaredMethod()
mengembalikan semua metode yang ada di dalam kelas.
Juga, kami telah membuat objek m dari Method
kelas. Di sini,
Method
class juga menyediakan berbagai metode lain yang dapat digunakan untuk memeriksa metode pada saat run time. Untuk mempelajari lebih lanjut, kunjungi kelas Metode Java (dokumentasi resmi Java).
Seperti metode, kita juga dapat memeriksa dan memodifikasi berbagai bidang kelas menggunakan metode Field
kelas. Misalnya,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
public String type;
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// access and set the type field
Field field1 = obj.getField("type");
field1.set(d1, "labrador");
// get the value of the field type
String typeValue = (String) field1.get(d1);
System.out.println("Value: " + typeValue);
// get the access modifier of the field type
int mod = field1.getModifiers();
// convert the modifier to String form
String modifier1 = Modifier.toString(mod);
System.out.println("Modifier: " + modifier1);
System.out.println(" ");
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Keluaran
Value: labrador Modifier: public
Pada contoh di atas, kami telah membuat kelas bernama Anjing . Ini termasuk bidang publik bernama type . Perhatikan pernyataannya,
Field field1 = obj.getField("type");
Di sini, kami mengakses bidang publik Anjing kelas dan menugaskannya ke objek field1 dari Bidang kelas.
Kami kemudian menggunakan berbagai metode Field
kelas:
Demikian pula, kami juga dapat mengakses dan memodifikasi bidang pribadi. Namun, refleksi dari ranah privat sedikit berbeda dengan ranah publik. Misalnya,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
private String color;
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// access the private field color
Field field1 = obj.getDeclaredField("color");
// allow modification of the private field
field1.setAccessible(true);
// set the value of color
field1.set(d1, "brown");
// get the value of field color
String colorValue = (String) field1.get(d1);
System.out.println("Value: " + colorValue);
// get the access modifier of color
int mod2 = field1.getModifiers();
// convert the access modifier to string
String modifier2 = Modifier.toString(mod2);
System.out.println("Modifier: " + modifier2);
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Keluaran
Value: brown Modifier: private
Pada contoh di atas, kami telah membuat kelas bernama Anjing . Kelas berisi bidang pribadi bernama warna . Perhatikan pernyataannya.
Field field1 = obj.getDeclaredField("color");
field1.setAccessible(true);
Di sini, kita mengakses color dan menugaskannya ke objek field1 dari Field
kelas. Kami kemudian menggunakan field1 untuk mengubah aksesibilitas warna dan memungkinkan kami untuk membuat perubahan padanya.
Kami kemudian menggunakan field1 untuk melakukan berbagai operasi pada warna bidang pribadi.
Untuk mempelajari lebih lanjut tentang berbagai metode Field , kunjungi Java Field Class (dokumentasi resmi Java).
Kami juga dapat memeriksa konstruktor kelas yang berbeda menggunakan berbagai metode yang disediakan oleh Constructor
kelas. Misalnya,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
// public constructor without parameter
public Dog() {
}
// private constructor with a single parameter
private Dog(int age) {
}
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// get all constructors of Dog
Constructor[] constructors = obj.getDeclaredConstructors();
for (Constructor c : constructors) {
// get the name of constructors
System.out.println("Constructor Name: " + c.getName());
// get the access modifier of constructors
// convert it into string form
int modifier = c.getModifiers();
String mod = Modifier.toString(modifier);
System.out.println("Modifier: " + mod);
// get the number of parameters in constructors
System.out.println("Parameters: " + c.getParameterCount());
System.out.println("");
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Keluaran
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
Pada contoh di atas, kami telah membuat kelas bernama Anjing . Kelas mencakup dua konstruktor.
Kami menggunakan refleksi untuk menemukan informasi tentang konstruktor kelas. Perhatikan pernyataannya,
Constructor[] constructors = obj.getDeclaredConstructor();
Di sini, kita mengakses semua konstruktor yang ada di Anjing dan menugaskannya ke array konstruktor dari Constructor
ketik.
Kami kemudian menggunakan objek c untuk mendapatkan informasi berbeda tentang konstruktor.
Untuk mempelajari lebih lanjut tentang metode Constructor
kelas, kunjungi kelas Konstruktor
java
Kelas Penulis Java Dalam tutorial ini, kita akan belajar tentang Java Writer, subclass-nya dan metodenya dengan bantuan sebuah contoh. Writer kelas java.io package adalah superclass abstrak yang mewakili aliran karakter. Sejak Writer adalah kelas abstrak, itu tidak berguna dengan sendirinya. Namun
Kelas InputStreamReader Java Dalam tutorial ini, kita akan belajar tentang Java InputStreamReader dan metodenya dengan bantuan contoh. InputStreamReader kelas java.io package dapat digunakan untuk mengubah data dalam byte menjadi data dalam karakter. Ini memperluas kelas abstrak Reader . InputS
Kelas OutputStreamWriter Java Dalam tutorial ini, kita akan belajar tentang Java OutputStreamWriter dan metodenya dengan bantuan contoh. OutputStreamWriter kelas java.io package dapat digunakan untuk mengubah data dalam bentuk karakter menjadi data dalam bentuk byte. Ini memperluas kelas abstrak W
Apa itu Refleksi di Java? Refleksi Java adalah proses menganalisis dan memodifikasi semua kemampuan kelas saat runtime. Reflection API di Java digunakan untuk memanipulasi kelas dan anggotanya yang meliputi bidang, metode, konstruktor, dll. saat runtime. Salah satu keuntungan dari API refleksi di