What's Going On in There? Java Reflection for Program Insight
In programming terms, reflection is a feature that allows you to see the internal composition of a programeverything from its variables to its method declarations. As its name indicates, the Java Reflection API enables this functionality in Java.
The Java Reflection API provides insight into the classes, interfaces, and objects in a given Java Virtual Machine (JVM). Developers commonly use the API to accomplish the following tasks, which explains why it is so often used to develop tools such as debuggers and Integrated Development Environments (IDEs):
- Determine the class of an object.
- Get information about a class's modifiers, fields, methods, constructors, etc.
- Get information about an interface's constants and method declarations.
- Create an instance of a class whose name is not known until runtime, but rather available at design time or provided as a runtime parameter.
- Get and set the value of an object's field, even if the field name is unknown to your program until runtime.
- Invoke a method on an object, even if the method is not known until runtime.
Using Reflection to Retrieve Class Behavior
To understand how you can use reflection to ascertain a class's behavior, consider the simple example of an Employee class:public class Employee { public String empNum; public String empName; public Employee() { this( "1", "King"); } public Employee(String empNum, String empName) { empNum = empNum; empName = empName; } public String toString() { return "Employee Details: EmpNumber: " + empNum + ",Compiling the Modifier classes and executing the AnalyzeClass produces the following output:
EmpName: "+ empNum; } } import java.lang.reflect.Modifier; public class AnalyzeClass { public static void main(String[] args) { Employee employee = new Employee(); Class klass = employee.getClass(); System.out.println( "Class name: " + klass.getName()); System.out.println( "Class super class: " + klass.getSuperclass()); int mods = klass.getModifiers(); System.out.println( "Class is public: " + Modifier.isPublic(mods)); System.out.println( "Class is final: " + Modifier.isFinal(mods)); System.out.println( "Class is abstract: " + Modifier.isAbstract(mods)); } }
Class name: Employee Class super class: class java.lang.Object Class is public: true Class is final: false Class is abstract: falseThis is basically an extract of the Employee class, so you are able to retrieve all the properties that it has. Need more convincing? Consider another example involving a Method class:
import java.lang.reflect.*; public class DumpMethods { public static void main(String args[]) { try { Class c = Class.forName(args[0]); Method m[] = c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) System.out.println(m[i].toString()); } catch (Throwable e) { System.err.println(e); } } }When you compile this code and invoke it with an argument of a known class...
java DumpMethods java.util.Stack...You receive the following result:
public synchronized java.lang.Object java.util.Stack.pop() public java.lang.Object java.util.Stack.push(java.lang.Object) public boolean java.util.Stack.empty() public synchronized java.lang.Object java.util.Stack.peek() public synchronized int java.util.Stack.search(java.lang.Object)The preceding output lists all the methods of the java.util.Stack class. Method is a class in java.lang.reflect, which is responsible for yielding this result.
Page 1 of 3
This article was originally published on May 12, 2009