Refleksi Jawa

Refleksi 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.

Refleksi Kelas Java

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.

Contoh:Refleksi Kelas Java

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 .

obj.getName() - mengembalikan nama kelas
obj.getModifiers() - mengembalikan pengubah akses kelas
obj.getSuperclass() - mengembalikan kelas super kelas

Untuk mempelajari lebih lanjut tentang Class , kunjungi Java Class (dokumentasi resmi Java).

Catatan :Kami menggunakan Modifier class untuk mengonversi pengubah akses integer menjadi string.

Merefleksikan Bidang, Metode, dan Konstruktor

Paket java.lang.reflect menyediakan kelas yang dapat digunakan untuk memanipulasi anggota kelas. Misalnya,

Kelas metode - memberikan informasi tentang metode dalam kelas
Kelas lapangan - memberikan informasi tentang bidang di kelas
Kelas konstruktor - memberikan informasi tentang konstruktor di kelas

1. Refleksi Metode Java

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,

m.getName() - mengembalikan nama metode
m.getModifiers() - mengembalikan pengubah akses metode dalam bentuk bilangan bulat
m.getReturnType() - mengembalikan tipe pengembalian metode

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).

2. Refleksi Bidang 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:

field1.set() - menetapkan nilai bidang
field1.get() - mengembalikan nilai bidang
field1.getModifiers() - mengembalikan nilai bidang dalam bentuk bilangan bulat

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).

3. Refleksi Konstruktor 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.

c.getName() - mengembalikan nama konstruktor
c.getModifiers() - mengembalikan pengubah akses konstruktor dalam bentuk integer
c.getParameterCount() - mengembalikan jumlah parameter yang ada di setiap konstruktor

Untuk mempelajari lebih lanjut tentang metode Constructor kelas, kunjungi kelas Konstruktor

String enum Java Pengecualian Jawa

java