Introduction
Java Reflection is a powerful API that allows a Java program to examine and manipulate information about its own classes at runtime. With Reflection, you can get information about a class's fields, methods, and constructors, and access and modify those elements even if they're private.
In this post we're going to write some Java codes exploring some of the facilities of using Reflection and when to apply it in your projects.
Bank Class
We'll create a simple class called Bank, where we'll create some fields, methods and constructors to be explored using Reflection.
Accessing the fields of the Bank class
With the Bank class created, let's explore via Reflection the listing of all fields of the class through the getDeclaredFields method of the Class class.
Note that through the static method Class.forName, we pass a string with the name of the class we want to explore via Reflection as a parameter.
Output
Field name: code
Field type: class java.lang.Integer
************
Field name: nameOfBank
Field type: class java.lang.String
************
Field name: amountOfDepositedMoney
Field type: class java.lang.Double
************
Field name: totalOfCustomers
Field type: class java.lang.Integer
************
Accessing the methods of the Bank class
Through the getDeclaredMethods method, we can retrieve all methods of the Bank class.
Output
Method name: doDeposit
Method type: class java.lang.String
************
Method name: doWithDraw
Method type: class java.lang.String
************
Method name: getReceipt
Method type: class java.lang.String
************
Creating objects
With the use of Reflection to create objects, it is necessary to create them through a constructor. In this case, we must first invoke a constructor to create the object. The detail is that to retrieve this constructor, we must pay attention to the types of parameters that make up the constructor and the order in which they are declared. This makes it flexible to retrieve different constructors with different parameter numbers and type in a class.
Notice below that it was necessary to create an array of type Class assigning different types according to the composition of the constructor that we will use to create our object. In this scenario, it will be necessary to invoke the method class.getConstructor(argType) passing the previously created array as an argument. This way, we will have a constructor object that will be used in the creation of our object.
Finally, we create a new array of type Object assigning the values ​​that will compose our object following the order defined in the constructor and then just invoke the method constructor.newInstance(argumentsValue) passing the array as a parameter returning the object we want to create.
Output
Bank{code=1, nameOfBank='Bank of America', amountOfDepositedMoney=1.5, totalOfCustomers=2500}
Invoking methods
To invoke a method through Reflection is quite simple as shown in the code below. Note that it is necessary to pass as a parameter in the method cls.getMethod("doDeposit", argumentsType) the explicit name of the method, in this case "doDeposit" and in the second parameter, an array representing the type of data used in the parameter of the method doDeposit( double amount), in this case a parameter of type double.
Finally, invoke the method method.invoke passing at the first parameter the object referencing the class, in this case an object of type Bank. And as the second parameter, the value that will be executed in the method.
Output
145.85 of money has been deposited
Conclusion
Using Reflection is a good strategy when you need flexibility in exploring different classes and their methods without the need to instantiate objects. Normally, Reflection is used in specific components of an architecture, but it does not prevent it from being used in different scenarios. From the examples shown above, you can see infinite scenarios of its application and the advantages of its use.
Hope you enjoyed!