Reflection in Java is a feature that allows us to inspect and manipulate the internal properties of objects, classes, and interfaces at runtime. This can be useful in cases where we need to dynamically load and use classes, or when we need to perform operations on objects without knowing their specific types beforehand.
Reflection is based on the concept of metadata, which is data that describes other data. In Java, metadata can be obtained through the use of classes such as Class, Field, Method, and Constructor. These classes are part of the java.lang.reflect package, which is used to obtain information about classes and objects at runtime.
Here are some common uses of reflection in Java:
Dynamic class loading: Reflection can be used to load classes at runtime, which can be useful for dynamically loading plugins or other types of extensions. For example, we can use the Class.forName() method to dynamically load a class by name, like this:
Class<?> clazz = Class.forName("com.example.MyClass");Inspecting objects at runtime: Reflection can be used to obtain information about an object’s class, fields, and methods at runtime. For example, we can use the getClass() method to obtain a Class object representing an object’s class, and then use methods such as getFields() and getMethods() to obtain information about the class’s fields and methods, respectively.
MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();
Field[] fields = clazz.getFields();
Method[] methods = clazz.getMethods();Modifying object properties at runtime: Reflection can also be used to modify the values of an object’s fields or invoke its methods at runtime. For example, we can use the set() method of the Field class to set the value of a field, and the invoke() method of the Method class to invoke a method.
MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();
Field field = clazz.getField("myField");
field.set(obj, "new value");
Method method = clazz.getMethod("myMethod");
method.invoke(obj);While reflection can be a powerful tool, it also has some limitations and performance overhead, so it should be used judiciously. In addition, the use of reflection can make the code more difficult to understand and maintain, so it should be used only when other solutions are not feasible.