Reflection Basics and Class Class

The standard J2SE platform libraries include a reflection API. This API allows classes to reflect on themselves, to see their inner selves. The reflection API lets you discover the name of classes, methods, and fields. You can also invoke those methods and access arrays without using square brackets.

The heart of the reflection API is the Class class. This class allows you to find out the name of a class, its access modifier, fields, methods, and so forth. For any instance of a class, you can get its Class class by calling the getClass method:

Class c = anInstance.getClass();

If you don't happen to have an instance of class (and don't want to create one), just attach .class to the end of the class name and you have the Class instance for that class.

Class c = MyClass.class;

The same even works for primitives:

Class c = int.class;

This last one might seem odd, but it allows you to specify argument types when calling methods (via Reflection) that accept primitive arguments.

One thing typically done is create a Class by passing its string name to the forName method of Class.

Class c = Class.forName(“java.awt.Button”);

This is done so that at the compile time you don't have to have the class within the quoted string available.

Once you have a Class class, you can find out the name of the class with its getName method:

Class c = java.awt.Button.class;

System.out.println(“Name: ” + c.getName());

Or, you can find out its superclass with its getSuperClass:

System.out.println(“Super: ” + c.getSuperClass().getName());

Moving from classes to methods takes us to the Method class, found in the java.lang.reflect package. With the Method class, you can discover all methods of a class (with getMethods) and even invoke them (with invoke).

The following program demostrates getting the mothods of a class:

import java.lang.reflect.*;

public class ListMethods {

public static void main(String[] args) {

if (args.length == 0) {

System.err.println(“Please include full qualified class name on command line”);

return;

}

for (int i = 0, n = args.length; i < n; ++i) {

listMethods(args[i]);

}

}

private static void listMethods(String name) {

try {

Class c = Class.forName(name);

System.out.println(“----” + c.getName() + “----”);

Method[] methods = c.getMethods();

for (int i = 0, n = methods.length; i < n; ++i) {

System.out.println(methods[i].getName());

System.out.println(“/t”, methods[i]);

}

} catch (ClassNotFoundException e) {

System.out.println(“Bad classname: “+ name);

}

}

}

Notice that the output includes all methods available through its superclass, too. To limit the output to only those methods declared in the class itself, change the getMethods call to getDeclaredMethods.

While the getMethods of Class allows you to get all the methods in a class, more typically, you want a specific method of a class. For that, there's the getMethod(String name, Class[] types) method. Once you have that method, you can invoke it with the invoke(Object instance, Object[] args) method. For static methods, the instance argument can be null.

The value for the arguments don't matter when finding a method, only the class types. At invoke time, you pass in the actual arguments values. For primitive types, you must box them up as objects (like using Integer for int).

The following demostrates invoking a method through reflection, and inserting a String in the middle of a StringBuffer.

StringBuffer buffer = new StringBuffer(“Held”);

Class c = buffer.getClass();

Class[] types = {int.class, String.class};

Method method = c.getMethod(“insert”, types);

Object[] theArgs = {new Integer(2), “llo, wor”};

method.invoke(buffer, theArgs);