The class java.lang.Class contains methods that return instances of classes/interfaces defined in the java.lang.reflect package. A detailed description of the API is beyond the scope of this article and can be found in any standard Java text. However, the classes that comprise the Reflection API are listed in Table 1.

The Introspection API
The Introspection API consists of several classes in the java.beans package. Again, a detailed description of the API is beyond the scope of this article and can be found in any standard Java text. The main classes in the Introspection API are listed in Table 2.

The Costs of Usage
Reflection and Introspection are powerful tools that contribute to the flexibility provided by the Java language. However, these APIs should be used only as needed and after taking into account the costs associated with their usage:

The Reflection and Introspection APIs should be used only when other forms of object-oriented programming are not appropriate.

The following examples demonstrate the use of Reflection and Introspection to develop some useful Java utilities.

Cookie Factory
Our first example illustrates the use of Reflection to build a utility that allows us to instantiate objects of types derived from a "Cookie" interface. The actual type of the object instantiated is determined by a String parameter, which contains the name of the actual class. The code for the example is shown in Listings 1and 2.

Listing 1 defines the Cookie interface and the derived classes. The Cookie interface is simply a marker interface which is implemented by the classes FortuneCookie and MisFortuneCookie. Both these classes define a single static method which prints out a string and returns a new instance of the respective class.

Listing 2 shows the CookieFactory class which is capable of producing objects derived from the "Cookie" interface. It defines a single method createCookie that takes a String parameter, className. The Class corresponding to this name is obtained from the Class class by calling

c = Class.forName(className);

Once we have the class, we need to obtain the method to be called on it. The name of the method is "newCookie." In this example, we are assuming that the name of the method is available at this point. The parameter types for the method are filled in an array of type Class and this is used to get the actual Method object as follows:

method = c.getMethod("newCookie", pTypes);

Once the Method object is available, the static method is invoked on the class after constructing an array of Objects that contains the actual parameter instances:

cookie = (Cookie)(method.invoke(c, params));

A simple tester for the class is provided in the main() method. This first constructs the CookieFactory and then creates instances of the FortuneCookie and MisFortuneCookie class. The output from the program is shown in Figure 3.

An X-Ray Class
Our second example illustrates the use of reflection to build a utility that allows us to view all the methods, constructors, fields, interfaces and inheritance for a supplied class. The class being X-rayed is specified by a String parameter which contains the name of the actual class. The code for the example is shown in Listing 4.

In order for the X-ray class program to determine the methods, constructors, fields and interfaces contained in the requested class, it must instantiate an object of the class by calling:

c = Class.forName(className);

After instantiating the class, the utility determines the selected operation on that class based on a second user-supplied string parameter, which can have one of the following values:

localMethods
allMethods
Constructors
fields
interface
inheritance

The local methods contained in the specified class may be found by calling:

methodList = c.getDeclaredMethods();

This call returns a Method[] that contains all the methods declared in the local class including private, protected and public. This call excludes inherited methods. A list of all the public methods, both inherited and local, may be obtained by calling:

methodList = c.getMethods();

Constructor methods are not included in the return Method[] of this call. Retrieving a list of constructors for a specific class can be accomplished by calling:

constructorList = c.getDeclaredConstructors();

This call returns a constructor[] that contains all of the private, protected and public constructors declared on the local class. A list that includes only the public constructors can be constructed by calling:

constructorList = c.getConstructors();

Class variables can be retrieved as Field[] information. To access a complete list of fields from a class including private, protected and public, we call:

fieldList = c.getDeclaredFields();A list that includes only the public fields can be retrieved by calling:

fieldList = c.getFields();

Information concerning the interfaces implemented by a class can be accessed by calling:

interfaceList = c.getInterfaces();

This call returns a Class[] that contains all of the interfaces implemented by the local class. Notice that this call doesn't have a getDeclaredInterfaces() counterpart like the other methods.

To access the inheritance information in the class, we get the name of each one of the superclasses in the inheritance tree. This is done in a while loop by calling:

classRef = c.getSuperclass();

We use this mechanism to return a class[] with all of the classes that participate in the extension of the local class. The output of the program for obtaining the inheritance hierarchy of the java.applet.Applet class is given in Figure 4.

Notice that of the various methods presented on this section, the only method that recursively provided information contained in its inheritance tree was the c.getMethods() call. The other methods only provided information contained by the local class.

An X-Ray Bean
Our third example illustrates the use of Introspection to build a utility that allows us to view all the methods, properties and events for a supplied JavaBean class. The Bean being X-rayed is specified by a String parameter which contains the name of the actual Bean class. The code for the example is shown in Listing 3.

In order for the X-ray Bean program to determine the methods, properties and events contained in the requested class, it must instantiate an object of the class by calling:

c = Class.forName(className);

After instantiating the class, the utility must access the BeanInfo for the instantiated Bean. BeanInfo data can be accessed via the Introspector class by calling:

bi = Introspector.getBeanInfo(c);

Next, the utility determines the selected operation on that class based on the second user-supplied parameter entered at the command line (i.e., methods, properties and events). The localMethods contained by the specified Bean can be found by calling:

methodDescriptorList = bi.getMethodDescriptors();

This call returns a MethodDescriptor[] that contains a description of all of the methods contained by this Bean. The type of method descriptor returned by this call contains a complete list of all the public methods contained within the inheritance tree of this Bean. In order to access the actual method instances, we need to iterate through the methodDescriptionList and obtain the method by calling:

methodRef = methodDescriptorList[i].getMethod();

From each one of these values, we are able to build a Method[] list that can be displayed by the utility. This includes no constructor method information. To access the Bean constructor information, you must use reflection.

Bean properties can be retrieved via PropertyDescriptors by calling:

PropertyDescriptorList = bi.getPropertyDescriptors();

This call returns a PropertyDescriptor[] that contains a description of all of the properties contained by this Bean. This includes name, readMethod, writeMethod, type, EditorClass, etc. Our utility uses this information to get the readMethod, writeMethod and property name via the PropertyDescriptor superclass (i.e., FeatureDescriptor) by calling:

methodRef = PropertyDescriptorList[i].getReadMethod();
methodRef = PropertyDescriptorList[i].getWriteMethod();
propertyName = PropertyDescriptorList[i].getName();

Bean events can be retrieved via EventSetDescriptors by calling:

eventSetDescriptorList = bi.getEventSetDescriptors();

This call returns an EventSetDescriptor[] that contains a description of all the methods associated with each event for this Bean. Our utility uses this information to get a Method[] for each one of the returned events in the eventSetDescriptorList. This is accomplished by calling:

methodList = eventSetDescriptorList[i].getListenerMethods();

This information is used to identify the methods associated to each one of the listener methods.

Information concerning the interfaces implemented by a class can be accessed by calling:

interfaceList = c.getInterfaces();

This call returns a class[] that contains all the interfaces implemented by the local class. Notice that this call doesn't have a getDeclaredInterfaces() counterpart like the other methods.

The output from the program for examining the events in the class, com.sun.swing.Jpanel is shown in Figure 5.

Conclusion

The traditional Adapter design pattern is defined as follows: Adapter: "Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces." [Design Patterns: Elements of Resuable Object-Oriented Software, Gamma et. al., Addison Wesley, 1995.]

Adapters are used when the input and output interfaces are known at compile-time. Dynamic Adapters will allow a program to dynamically map the interfaces at runtime. We will examine these patterns in more detail in the next article.