In Java, reflection allows us to inspect and manipulate classes, interfaces, constructors, methods, and fields at run time.
There is a class in Java named Class that keeps all the information about objects and classes at runtime. The object of Class can be used to perform reflection.
Reflection of Java Classes
In order to reflect a Java class, we first need to create an object of Class.
And, using the object we can call various methods to get information about methods, fields, and constructors present in a class.
There exists three ways to create objects of Class:
1. Using forName() method
class Dog {...}
// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");
Here, the forName() method takes the name of the class to be reflected as its argument.
2. Using getClass() method
// create an object of Dog class
Dog d1 = new Dog();
// create an object of Class
// to reflect Dog
Class b = d1.getClass();
Here, we are using the object of the Dog class to create an object of Class.
3. Using .class extension
// create an object of Class
// to reflect the Dog class
Class c = Dog.class;
Now that we know how we can create objects of the Class. We can use this object to get information about the corresponding class at runtime.
Example: Java Class Reflection
Output
Name: Dog Modifier: public Superclass: Animal
In the above example, we have created a superclass: Animal and a subclass: Dog. Here, we are trying to inspect the class Dog.
Notice the statement,
Class obj = d1.getClass();
Here, we are creating an object obj of Class using the getClass() method. Using the object, we are calling different methods of Class.
- obj.getName() - returns the name of the class
- obj.getModifiers() - returns the access modifier of the class
- obj.getSuperclass() - returns the super class of the class
To learn more about Class, visit Java Class (official Java documentation).
Note: We are using the Modifier class to convert the integer access modifier to a string.
Reflecting Fields, Methods, and Constructors
The package java.lang.reflect provides classes that can be used for manipulating class members. For example,
- Method class - provides information about methods in a class
- Field class - provides information about fields in a class
- Constructor class - provides information about constructors in a class
1. Reflection of Java Methods
The Method class provides various methods that can be used to get information about the methods present in a class. For example,
Output
Method Name: display Modifier: public Return Types: void Method Name: makeSound Modifier: private Return Types: void
In the above example, we are trying to get information about the methods present in the Dog class. As mentioned earlier, we have first created an object obj of Class using the getClass() method.
Notice the expression,
Method[] methods = obj.getDeclaredMethod();
Here, the getDeclaredMethod() returns all the methods present inside the class.
Also, we have created an object m of the Method class. Here,
- m.getName() - returns the name of a method
- m.getModifiers() - returns the access modifier of methods in integer form
- m.getReturnType() - returns the return type of methods
The Method class also provides various other methods that can be used to inspect methods at run time. To learn more, visit the Java Method class (official Java documentation).
2. Reflection of Java Fields
Like methods, we can also inspect and modify different fields of a class using the methods of the Field class. For example,
Output
Value: labrador Modifier: public
In the above example, we have created a class named Dog. It includes a public field named type. Notice the statement,
Field field1 = obj.getField("type");
Here, we are accessing the public field of the Dog class and assigning it to the object field1 of the Field class.
We then used various methods of the Field class:
- field1.set() - sets the value of the field
- field1.get() - returns the value of field
- field1.getModifiers() - returns the value of the field in integer form
Similarly, we can also access and modify private fields as well. However, the reflection of private field is little bit different than the public field. For example,
Output
Value: brown Modifier: private
In the above example, we have created a class named Dog. The class contains a private field named color. Notice the statement.
Field field1 = obj.getDeclaredField("color");
field1.setAccessible(true);
Here, we are accessing color and assigning it to the object field1 of the Field class. We then used field1 to modify the accessibility of color and allows us to make changes to it.
We then used field1 to perform various operations on the private field color.
To learn more about the different methods of Field, visit Java Field Class (official Java documentation).
3. Reflection of Java Constructor
We can also inspect different constructors of a class using various methods provided by the Constructor class. For example,
Output
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
In the above example, we have created a class named Dog. The class includes two constructors.
We are using reflection to find the information about the constructors of the class. Notice the statement,
Constructor[] constructors = obj.getDeclaredConstructor();
Here, the we are accessing all the constructors present in Dog and assigning them to an array constructors of the Constructor type.
We then used object c to get different informations about the constructor.
- c.getName() - returns the name of the constructor
- c.getModifiers() - returns the access modifiers of the constructor in integer form
- c.getParameterCount() - returns the number of parameters present in each constructor
To learn about more methods of the Constructor class, visit Constructor class