RE: What are the practical uses of Java Reflection?
I have heard about Java Reflection, but I am unsure of its practical applications. Can someone explain with examples?
Java Reflection is a powerful feature which allows you to inspect, monitor and manipulate runtime attributes of classes, interfaces, fields and methods. It’s called reflection because it lets you ‘reflect’ the inner workings of a program.
Here are some of its practical uses:
1. **Exploring the Metadata:** Reflection allows us to obtain the names of class members, their modifiers, annotations, and data types. This is particularly useful while creating tools such as debuggers, IDEs, code viewers, and visual representations of code.
2. **Dynamic Loading:** Reflection allows us to dynamically load classes at runtime. This can be used to increase the extensibility of your application. For instance, JDBC drivers are dynamically loaded before use.
3. **Testing Private Methods:** Sometimes, for unit testing purposes, it's needed to access private methods. Using reflection, we can do this, although it's not a good practice.
4. **Manipulating Objects:** Reflection can create and manipulate objects without knowing their type. This is necessary in object serialization, which involves turning objects into a stream of bytes and vice versa.
Here's a small example of reflection where we fetch method names of a class:
```java
import java.lang.reflect.Method;
public class Test {
// create a method
public void myMethod() {
System.out.println("Reflection Example!");
}
public static void main(String args[]) {
try {
// create an object of Test
Test test = new Test();
// create an object of Class using getClass method
Class obj = test.getClass();
// get all methods of the class
Method[] methods = obj.getMethods();
// print method names
for (Method method : methods)
System.out.println("Method Name: " + method.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
This will output:
```
Method Name: myMethod
Method Name: wait
Method Name: wait
Method Name: wait
Method Name: equals
Method Name: toString
Method Name: hashCode
Method Name: getClass
Method Name: notify
Method Name: notifyAll
```
While reflection provides great power, be aware it presents certain drawbacks. It can breach the security and integrity of classes by manipulating their private members, it may lead to poor performance due to overhead, and it can induce complexity. So, use it sparingly and responsibly.