Java-reflectie
Java-reflectie
In deze zelfstudie leren we reflectie, een functie in Java-programmering waarmee we klassen, methoden, enz. kunnen inspecteren en wijzigen.
In Java stelt reflectie ons in staat om tijdens runtime klassen, interfaces, constructors, methoden en velden te inspecteren en te manipuleren.
Er is een klasse in Java genaamd Class die alle informatie over objecten en klassen tijdens runtime bewaart. Het object van Klasse kan worden gebruikt om reflectie uit te voeren.
Weerspiegeling van Java-klassen
Om een Java-klasse weer te geven, moeten we eerst een object van Class . maken .
En met behulp van het object kunnen we verschillende methoden aanroepen om informatie te krijgen over methoden, velden en constructors die aanwezig zijn in een klasse.
Er zijn drie manieren om objecten van Class te maken:
class Dog {...}
// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");
Hier, de forName() methode neemt de naam van de klasse die moet worden weerspiegeld als argument.
// create an object of Dog class
Dog d1 = new Dog();
// create an object of Class
// to reflect Dog
Class b = d1.getClass(); Hier gebruiken we het object van de Hond class om een object van Class . te maken .
// create an object of Class
// to reflect the Dog class
Class c = Dog.class;
Nu we weten hoe we objecten van de Class . kunnen maken . We kunnen dit object gebruiken om informatie te krijgen over de corresponderende klasse tijdens runtime.
Voorbeeld:Java Class Reflection
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();
}
}
} Uitvoer
Name: Dog Modifier: public Superclass: Animal
In het bovenstaande voorbeeld hebben we een superklasse gemaakt:Animal en een subklasse:Hond . Hier proberen we de klasse Hond te inspecteren .
Let op de verklaring,
Class obj = d1.getClass();
Hier maken we een object obj van Klasse met behulp van de getClass() methode. Met behulp van het object roepen we verschillende methoden van Klasse . aan .
- obj.getName() - geeft de naam van de klas terug
- obj.getModifiers() - geeft de toegangsmodifier van de klasse terug
- obj.getSuperclass() - geeft de superklasse van de klasse terug
Voor meer informatie over Class , bezoek Java Class (officiële Java-documentatie).
Opmerking :We gebruiken de Modifier class om de toegangsmodifier voor gehele getallen om te zetten in een tekenreeks.
Reflecterende velden, methoden en constructors
Het pakket java.lang.reflect biedt klassen die kunnen worden gebruikt voor het manipuleren van klasleden. Bijvoorbeeld,
- Methodeklasse - geeft informatie over methoden in een klasse
- Veldklasse - geeft informatie over velden in een klas
- Constructeursklasse - geeft informatie over constructeurs in een klasse
1. Weerspiegeling van Java-methoden
De Method class biedt verschillende methoden die kunnen worden gebruikt om informatie te krijgen over de methoden die in een klasse aanwezig zijn. Bijvoorbeeld,
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();
}
}
} Uitvoer
Method Name: display Modifier: public Return Types: void Method Name: makeSound Modifier: private Return Types: void
In het bovenstaande voorbeeld proberen we informatie te krijgen over de methoden die aanwezig zijn in de Hond klas. Zoals eerder vermeld, hebben we eerst een object obj . gemaakt van Class met behulp van de getClass() methode.
Let op de uitdrukking,
Method[] methods = obj.getDeclaredMethod();
Hier, de getDeclaredMethod() geeft alle methoden terug die aanwezig zijn in de klasse.
We hebben ook een object m . gemaakt van de Method klas. Hier,
- m.getName() - geeft de naam van een methode terug
- m.getModifiers() - geeft de toegangsmodificator van methoden terug in de vorm van een geheel getal
- m.getReturnType() - retourneert het retourtype van methoden
De Method class biedt ook verschillende andere methoden die kunnen worden gebruikt om methoden tijdens runtime te inspecteren. Ga voor meer informatie naar de Java Method-klasse (officiële Java-documentatie).
2. Weerspiegeling van Java-velden
Net als methoden kunnen we ook verschillende velden van een klasse inspecteren en wijzigen met behulp van de methoden van de Field klas. Bijvoorbeeld,
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();
}
}
} Uitvoer
Value: labrador Modifier: public
In het bovenstaande voorbeeld hebben we een klasse gemaakt met de naam Hond . Het bevat een openbaar veld met de naam type . Let op de verklaring,
Field field1 = obj.getField("type"); Hier hebben we toegang tot het openbare veld van de Hond class en toewijzen aan het object field1 van het Veld klasse.
We gebruikten vervolgens verschillende methoden van de Field klas:
- field1.set() - stelt de waarde van het veld in
- field1.get() - geeft de waarde van veld terug
- field1.getModifiers() - geeft de waarde van het veld terug in de vorm van een geheel getal
Op dezelfde manier kunnen we ook privévelden openen en wijzigen. De weerspiegeling van het private veld is echter een beetje anders dan het publieke veld. Bijvoorbeeld,
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();
}
}
} Uitvoer
Value: brown Modifier: private
In het bovenstaande voorbeeld hebben we een klasse gemaakt met de naam Hond . De klasse bevat een privéveld met de naam color . Let op de verklaring.
Field field1 = obj.getDeclaredField("color");
field1.setAccessible(true);
Hier hebben we toegang tot kleur en toe te wijzen aan het object veld1 van de Field klas. We gebruikten toen field1 om de toegankelijkheid van kleur te wijzigen en stelt ons in staat er wijzigingen in aan te brengen.
Vervolgens hebben we veld1 gebruikt om verschillende bewerkingen uit te voeren op de privéveldkleur.
Voor meer informatie over de verschillende methoden van Field , bezoek Java Field Class (officiële Java-documentatie).
3. Weerspiegeling van Java Constructor
We kunnen ook verschillende constructors van een klasse inspecteren met behulp van verschillende methoden die worden geboden door de Constructor klas. Bijvoorbeeld,
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();
}
}
} Uitvoer
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
In het bovenstaande voorbeeld hebben we een klasse gemaakt met de naam Hond . De klasse bevat twee constructeurs.
We gebruiken reflectie om de informatie over de constructeurs van de klasse te vinden. Let op de verklaring,
Constructor[] constructors = obj.getDeclaredConstructor();
Hier hebben we toegang tot alle constructors die aanwezig zijn in Dog en toewijzen aan een array constructors van de Constructor typ.
We gebruikten toen object c om verschillende informatie over de constructor te krijgen.
- c.getName() - geeft de naam van de constructor terug
- c.getModifiers() - geeft de toegangsmodifiers van de constructor terug in de vorm van een geheel getal
- c.getParameterCount() - geeft het aantal parameters terug dat aanwezig is in elke constructor
Voor meer informatie over meer methoden van de Constructor klas, bezoek Constructor klas
Java