Core Java(TM) 2, Volume I--Fundamentals (7th Edition) (Core Series) (Core Series)

The reflection library gives you a very rich and elaborate toolset to write programs that manipulate Java code dynamically. This feature is heavily used in JavaBeans, the component architecture for Java (see Volume 2 for more on JavaBeans). Using reflection, Java can support tools like the ones to which users of Visual Basic have grown accustomed. In particular, when new classes are added at design or run time, rapid application development tools can dynamically inquire about the capabilities of the classes that were added.

A program that can analyze the capabilities of classes is called reflective. The reflection mechanism is extremely powerful. As the next sections show, you can use it to

• Analyze the capabilities of classes at run time;

• Inspect objects at run time, for example, to write a single toString method that works for all classes;

• Implement generic array manipulation code; and

• Take advantage of Method objects that work just like function pointers in languages such as C++.

Reflection is a powerful and complex mechanism; however, it is of interest mainly to tool builders, not application programmers. If you are interested in programming applications rather than tools for other Java programmers, you can safely skip the remainder of this chapter and return to it later.

The Class Class

While your program is running, the Java runtime system always maintains what is called runtime type identification on all objects. This information keeps track of the class to which each object belongs. Runtime type information is used by the virtual machine to select the correct methods to execute.

However, you can also access this information by working with a special Java class. The class that holds this information is called, somewhat confusingly, Class. The getClass() method in the Object class returns an instance of Class type.

Employee e; . . . Class cl = e.getClass();

Just like an Employee object describes the properties of a particular employee, a Class object describes the properties of a particular class. Probably the most commonly used method of Class is getName. This returns the name of the class. For example, the statement

System.out.println(e.getClass().getName() + " " + e.getName());

prints

Employee Harry Hacker

if e is an employee, or

Manager Harry Hacker

if e is a manager.

You can also obtain a Class object corresponding to a string by using the static forName method.

String className = "java.util.Date"; Class cl = Class.forName(className);

You would use this method if the class name is stored in a string that varies at run time. This works if className is the name of a class or interface. Otherwise, the forName method throws a checked exception. See the sidebar "Catching Exceptions" on page 192 to see how to supply an exception handler whenever you use this method.

TIP

A third method for obtaining an object of type Class is a convenient shorthand. If T is any Java type, then T.class is the matching class object. For example:

Class cl1 = Date.class; // if you import java.util.*; Class cl2 = int.class; Class cl3 = Double[].class;

Note that a Class object really describes a type, which may or may not be a class. For example, int is not a class, but int.class is nevertheless an object of type Class.

NOTE

CAUTION

The virtual machine manages a unique Class object for each type. Therefore, you can use the == operator to compare class objects, for example,

if (e.getClass() == Employee.class) . . .

Another example of a useful method is one that lets you create an instance of a class on the fly. This method is called, naturally enough, newInstance(). For example,

e.getClass().newInstance();

creates a new instance of the same class type as e. The newInstance method calls the default constructor (the one that takes no parameters) to initialize the newly created object. An exception is thrown if the class has no default constructor.

Using a combination of forName and newInstance lets you create an object from a class name stored in a string.

String s = "java.util.Date"; Object m = Class.forName(s).newInstance();

NOTE

C++ NOTE

java.lang.Class 1.0

• static Class forName(String className)

  returns the Class object representing the class with name className.

• Object newInstance()

  returns a new instance of this class.

java.lang.reflect.Constructor 1.1

• Object newInstance(Object[] args)

  constructs a new instance of the constructor's declaring class.

  Parameters:	args	the parameters supplied to the constructor. See the section on reflection for more information on how to supply parameters.

java.lang.Throwable 1.0

• void printStackTrace()

  prints the Throwable object and the stack trace to the standard error stream.

Using Reflection to Analyze the Capabilities of Classes

Here is a brief overview of the most important parts of the reflection mechanism for letting you examine the structure of a class.

The three classes Field, Method, and Constructor in the java.lang.reflect package describe the fields, methods, and constructors of a class, respectively. All three classes have a method called getName that returns the name of the item. The Field class has a method getType that returns an object, again of type Class, that describes the field type. The Method and Constructor classes have methods to report the types of the parameters, and the Method class also reports the return type. All three of these classes also have a method called getModifiers that returns an integer, with various bits turned on and off, that describes the modifiers used, such as public and static. You can then use the static methods in the Modifier class in the java.lang.reflect package to analyze the integer that getModifiers returns. Use methods like isPublic, isPrivate, or isFinal in the Modifier class to tell whether a method or constructor was public, private, or final. All you have to do is have the appropriate method in the Modifier class work on the integer that getModifiers returns. You can also use the Modifier.toString method to print the modifiers.

The getFields, getMethods, and getConstructors methods of the Class class return arrays of the public fields, methods, and constructors that the class supports. This includes public members of superclasses. The getdeclaredFields, geTDeclaredMethods, and geTDeclaredConstructors methods of the Class class return arrays consisting of all fields, operations, and constructors that are declared in the class. This includes private and protected members, but not members of superclasses.

Example 5-5 shows you how to print out all information about a class. The program prompts you for the name of a class and then writes out the signatures of all methods and constructors as well as the names of all data fields of a class. For example, if you enter

java.lang.Double

then the program prints:

class java.lang.Double extends java.lang.Number { public java.lang.Double(java.lang.String); public java.lang.Double(double); public int hashCode(); public int compareTo(java.lang.Object); public int compareTo(java.lang.Double); public boolean equals(java.lang.Object); public java.lang.String toString(); public static java.lang.String toString(double); public static java.lang.Double valueOf(java.lang.String); public static boolean isNaN(double); public boolean isNaN(); public static boolean isInfinite(double); public boolean isInfinite(); public byte byteValue(); public short shortValue(); public int intValue(); public long longValue(); public float floatValue(); public double doubleValue(); public static double parseDouble(java.lang.String); public static native long doubleToLongBits(double); public static native long doubleToRawLongBits(double); public static native double longBitsToDouble(long); public static final double POSITIVE_INFINITY; public static final double NEGATIVE_INFINITY; public static final double NaN; public static final double MAX_VALUE; public static final double MIN_VALUE; public static final java.lang.Class TYPE; private double value; private static final long serialVersionUID; }

What is remarkable about this program is that it can analyze any class that the Java interpreter can load, not just the classes that were available when the program was compiled. We use this program in the next chapter to peek inside the inner classes that the Java compiler generates automatically.

Example 5-5. ReflectionTest.java

1. import java.util.*; 2. import java.lang.reflect.*; 3. 4. public class ReflectionTest 5. { 6. public static void main(String[] args) 7. { 8. // read class name from command-line args or user input 9. String name; 10. if (args.length > 0) 11. name = args[0]; 12. else 13. { 14. Scanner in = new Scanner(System.in); 15. System.out.println("Enter class name (e.g. java.util.Date): "); 16. name = in.next(); 17. } 18. 19. try 20. { 21. // print class name and superclass name (if != Object) 22. Class cl = Class.forName(name); 23. Class supercl = cl.getSuperclass(); 24. System.out.print("class " + name); 25. if (supercl != null && supercl != Object.class) 26. System.out.print(" extends " + supercl.getName()); 27. 28. System.out.print("\n{\n"); 29. printConstructors(cl); 30. System.out.println(); 31. printMethods(cl); 32. System.out.println(); 33. printFields(cl); 34. System.out.println("}"); 35. } 36. catch(ClassNotFoundException e) { e.printStackTrace(); } 37. System.exit(0); 38. } 39. 40. /** 41. Prints all constructors of a class 42. @param cl a class 43. */ 44. public static void printConstructors(Class cl) 45. { 46. Constructor[] constructors = cl.getDeclaredConstructors(); 47. 48. for (Constructor c : constructors) 49. { 50. String name = c.getName(); 51. System.out.print(" " + Modifier.toString(c.getModifiers())); 52. System.out.print(" " + name + "("); 53. 54. // print parameter types 55. Class[] paramTypes = c.getParameterTypes(); 56. for (int j = 0; j < paramTypes.length; j++) 57. { 58. if (j > 0) System.out.print(", "); 59. System.out.print(paramTypes[j].getName()); 60. } 61. System.out.println(");"); 62. } 63. } 64. 65. /** 66. Prints all methods of a class 67. @param cl a class 68. */ 69. public static void printMethods(Class cl) 70. { 71. Method[] methods = cl.getDeclaredMethods(); 72. 73. for (Method m : methods) 74. { 75. Class retType = m.getReturnType(); 76. String name = m.getName(); 77. 78. // print modifiers, return type and method name 79. System.out.print(" " + Modifier.toString(m.getModifiers())); 80. System.out.print(" " + retType.getName() + " " + name + "("); 81. 82. // print parameter types 83. Class[] paramTypes = m.getParameterTypes(); 84. for (int j = 0; j < paramTypes.length; j++) 85. { 86. if (j > 0) System.out.print(", "); 87. System.out.print(paramTypes[j].getName()); 88. } 89. System.out.println(");"); 90. } 91. } 92. 93. /** 94. Prints all fields of a class 95. @param cl a class 96. */ 97. public static void printFields(Class cl) 98. { 99. Field[] fields = cl.getDeclaredFields(); 100. 101. for (Field f : fields) 102. { 103. Class type = f.getType(); 104. String name = f.getName(); 105. System.out.print(" " + Modifier.toString(f.getModifiers())); 106. System.out.println(" " + type.getName() + " " + name + ";"); 107. } 108. } 109. }

java.lang.Class 1.0

• Field[] getFields() 1.1

• Field[] getDeclaredFields() 1.1

  The getFields method returns an array containing Field objects for the public fields of this class or its superclasses. The geTDeclaredField method returns an array of Field objects for all fields of this class. The methods return an array of length 0 if there are no such fields or if the Class object represents a primitive or array type.

• Method[] getMethods() 1.1

• Method[] getDeclaredMethods() 1.1

  return an array containing Method objects: getMethods returns public methods and includes inherited methods; getdeclaredMethods returns all methods of this class or interface but does not include inherited methods.

• Constructor[] getConstructors() 1.1

• Constructor[] getDeclaredConstructors() 1.1

  return an array containing Constructor objects that give you all the public constructors (for getConstructors) or all constructors (for getdeclaredConstructors) of the class represented by this Class object.

java.lang.reflect.Field 1.1

java.lang.reflect.Method 1.1

java.lang.reflect.Constructor 1.1

• Class getDeclaringClass()

  returns the Class object for the class that defines this constructor, method, or field.

• Class[] getExceptionTypes() (in Constructor and Method classes)

  returns an array of Class objects that represent the types of the exceptions thrown by the method.

• int getModifiers()

  returns an integer that describes the modifiers of this constructor, method, or field. Use the methods in the Modifier class to analyze the return value.

• String getName()

  returns a string that is the name of the constructor, method, or field.

• Class[] getParameterTypes() (in Constructor and Method classes)

  returns an array of Class objects that represent the types of the parameters.

• Class getReturnType() (in Method classes)

  returns a Class object that represents the return type.

java.lang.reflect.Modifier 1.1

• static String toString(int modifiers)

  returns a string with the modifiers that correspond to the bits set in modifiers.

• static boolean isAbstract(int modifiers)

• static boolean isFinal(int modifiers)

• static boolean isInterface(int modifiers)

• static boolean isNative(int modifiers)

• static boolean isPrivate(int modifiers)

• static boolean isProtected(int modifiers)

• static boolean isPublic(int modifiers)

• static boolean isStatic(int modifiers)

• static boolean isStrict(int modifiers)

• static boolean isSynchronized(int modifiers)

• static boolean isVolatile(int modifiers)

  These methods test the bit in the modifiers value that corresponds to the modifier in the method name.

Using Reflection to Analyze Objects at Run Time

In the preceding section, we saw how we can find out the names and types of the data fields of any object:

• Get the corresponding Class object.

• Call getdeclaredFields on the Class object.

In this section, we go one step further and actually look at the contents of the data fields. Of course, it is easy to look at the contents of a specific field of an object whose name and type are known when you write a program. But reflection lets you look at fields of objects that were not known at compile time.

The key method to achieve this examination is the get method in the Field class. If f is an object of type Field (for example, one obtained from getdeclaredFields) and obj is an object of the class of which f is a field, then f.get(obj) returns an object whose value is the current value of the field of obj. This is all a bit abstract, so let's run through an example.

Employee harry = new Employee("Harry Hacker", 35000, 10, 1, 1989); Class cl = harry.getClass(); // the class object representing Employee Field f = cl.getDeclaredField("name"); // the name field of the Employee class Object v = f.get(harry); // the value of the name field of the harry object // i.e., the String object "Harry Hacker"

Actually, there is a problem with this code. Because the name field is a private field, the get method will throw an IllegalAccessException. You can only use the get method to get the values of accessible fields. The security mechanism of Java lets you find out what fields any object has, but it won't let you read the values of those fields unless you have access permission.

The default behavior of the reflection mechanism is to respect Java access control. However, if a Java program is not controlled by a security manager that disallows it, you can override access control. To do this, invoke the setAccessible method on a Field, Method, or Constructor object, for example:

f.setAccessible(true); // now OK to call f.get(harry);

The setAccessible method is a method of the AccessibleObject class, the common superclass of the Field, Method, and Constructor classes. This feature is provided for debuggers, persistent storage, and similar mechanisms. We use it for a generic toString method later in this section.

There is another issue with the get method that we need to deal with. The name field is a String, and so it is not a problem to return the value as an Object. But suppose we want to look at the salary field. That is a double, and in Java, number types are not objects. To handle this, you can either use the getdouble method of the Field class, or you can call get, whereby the reflection mechanism automatically wraps the field value into the appropriate wrapper class, in this case, Double.

Of course, you can also set the values that you can get. The call f.set(obj, value) sets the field represented by f of the object obj to the new value.

Example 5-6 shows how to write a generic toString method that works for any class. It uses getdeclaredFields to obtain all data fields. It then uses the setAccessible convenience method to make all fields accessible. For each field, it obtains the name and the value. Example 5-6 turns each value into a string by recursively invoking toString.

class ObjectAnalyzer { public String toString(Object obj) { Class cl = obj.getClass(); . . . String r = cl.getName(); // inspect the fields of this class and all superclasses do { r += "["; Field[] fields = cl.getDeclaredFields(); AccessibleObject.setAccessible(fields, true); // get the names and values of all fields for (Field f : fields) { if (!Modifier.isStatic(f.getModifiers())) { if (!r.endsWith("[")) r += "," r += f.getName() + "="; try { Object val = f.get(obj); r += toString(val); } catch (Exception e) { e.printStackTrace(); } } } r += "]"; cl = cl.getSuperclass(); } while (cl != Object.class); return r; } . . . }

The complete code in Example 5-6 needs to address a couple of complexities. Cycles of references could cause an infinite recursion. Therefore, the ObjectAnalyzer keeps track of objects that were already visited. Also, to peek inside arrays, you need a different approach. You'll learn about the details in the next section.

You can use this toString method to peek inside any object. For example, the call

ArrayList<Integer> squares = new ArrayList<Integer>(); for (int i = 1; i <= 5; i++) squares.add(i * i); System.out.println(new ObjectAnalyzer().toString(squares));

yields the printout:

java.util.ArrayList[elementData=class java.lang.Object[]{java.lang.Integer[value=1][][], java.lang.Integer[value=4][][],java.lang.Integer[value=9][][],java.lang.Integer[value=16][][], java.lang.Integer[value=25][][],null,null,null,null,null},size=5][modCount=5][][]

You can use this generic toString method to implement the toString methods of your own classes, like this:

public String toString() { return new ObjectAnalyzer().toString(this); }

This is a hassle-free method for supplying a toString method that you may find useful in your own programs.

Example 5-6. ObjectAnalyzerTest.java

1. import java.lang.reflect.*; 2. import java.util.*; 3. import java.text.*; 4. 5. public class ObjectAnalyzerTest 6. { 7. public static void main(String[] args) 8. { 9. ArrayList<Integer> squares = new ArrayList<Integer>(); 10. for (int i = 1; i <= 5; i++) squares.add(i * i); 11. System.out.println(new ObjectAnalyzer().toString(squares)); 12. } 13. } 14. 15. class ObjectAnalyzer 16. { 17. /** 18. Converts an object to a string representation that lists 19. all fields. 20. @param obj an object 21. @return a string with the object's class name and all 22. field names and values 23. */ 24. public String toString(Object obj) 25. { 26. if (obj == null) return "null"; 27. if (visited.contains(obj)) return "..."; 28. visited.add(obj); 29. Class cl = obj.getClass(); 30. if (cl == String.class) return (String) obj; 31. if (cl.isArray()) 32. { 33. String r = cl.getComponentType() + "[]{"; 34. for (int i = 0; i < Array.getLength(obj); i++) 35. { 36. if (i > 0) r += ","; 37. Object val = Array.get(obj, i); 38. if (cl.getComponentType().isPrimitive()) r += val; 39. else r += toString(val); 40. } 41. return r + "}"; 42. } 43. 44. String r = cl.getName(); 45. // inspect the fields of this class and all superclasses 46. do 47. { 48. r += "["; 49. Field[] fields = cl.getDeclaredFields(); 50. AccessibleObject.setAccessible(fields, true); 51. // get the names and values of all fields 52. for (Field f : fields) 53. { 54. if (!Modifier.isStatic(f.getModifiers())) 55. { 56. if (!r.endsWith("[")) r += ","; 57. r += f.getName() + "="; 58. try 59. { 60. Class t = f.getType(); 61. Object val = f.get(obj); 62. if (t.isPrimitive()) r += val; 63. else r += toString(val); 64. } 65. catch (Exception e) { e.printStackTrace(); } 66. } 67. } 68. r += "]"; 69. cl = cl.getSuperclass(); 70. } 71. while (cl != null); 72. 73. return r; 74. } 75. 76. private ArrayList<Object> visited = new ArrayList<Object>(); 77. }

java.lang.reflect.AccessibleObject 1.2

• void setAccessible(boolean flag)

  sets the accessibility flag for this reflection object. A value of true indicates that Java language access checking is suppressed and that the private properties of the object can be queried and set.

• boolean isAccessible()

  gets the value of the accessibility flag for this reflection object.

• static void setAccessible(AccessibleObject[] array, boolean flag)

  is a convenience method to set the accessibility flag for an array of objects.

java.lang.Class 1.1

• Field getField(String name)

• Field[] getFields()

  gets the public field with the given name, or an array of all fields.

• Field getDeclaredField(String name)

• Field[] getDeclaredFields()

  gets the field that is declared in this class with the given name, or an array of all fields.

java.lang.reflect.Field 1.1

• Object get(Object obj)

  gets the value of the field described by this Field object in the object obj.

• void set(Object obj, Object newValue)

  sets the field described by this Field object in the object obj to a new value.

Using Reflection to Write Generic Array Code

The Array class in the java.lang.reflect package allows you to create arrays dynamically. For example, when you use this feature with the arrayCopy method from Chapter 3, you can dynamically expand an existing array while preserving the current contents.

The problem we want to solve is pretty typical. Suppose you have an array of some type that is full and you want to grow it. And suppose you are sick of writing the grow-and-copy code by hand. You want to write a generic method to grow an array.

Employee[] a = new Employee[100]; . . . // array is full a = (Employee[]) arrayGrow(a);

How can we write such a generic method? It helps that an Employee[] array can be converted to an Object[] array. That sounds promising. Here is a first attempt to write a generic method. We simply grow the array by 10% + 10 elements (because the 10 percent growth is not substantial enough for small arrays).

static Object[] badArrayGrow(Object[] a) // not useful { int newLength = a.length * 11 / 10 + 10; Object[] newArray = new Object[newLength]; System.arraycopy(a, 0, newArray, 0, a.length); return newArray; }

However, there is a problem with actually using the resulting array. The type of array that this code returns is an array of objects (Object[]) because we created the array using the line of code

new Object[newLength]

An array of objects cannot be cast to an array of employees (Employee[]). Java would generate a ClassCastException at run time. The point is, as we mentioned earlier, that a Java array remembers the type of its entries, that is, the element type used in the new expression that created it. It is legal to cast an Employee[] temporarily to an Object[] array and then cast it back, but an array that started its life as an Object[] array can never be cast into an Employee[] array. To write this kind of generic array code, we need to be able to make a new array of the same type as the original array. For this, we need the methods of the Array class in the java.lang.reflect package. The key is the static newInstance method of the Array class that constructs a new array. You must supply the type for the entries and the desired length as parameters to this method.

Object newArray = Array.newInstance(componentType, newLength);

To actually carry this out, we need to get the length and component type of the new array.

We obtain the length by calling Array.getLength(a). The static getLength method of the Array class returns the length of any array. To get the component type of the new array:

1. First, get the class object of a.

2. Confirm that it is indeed an array.

3. Use the getComponentType method of the Class class (which is defined only for class objects that represent arrays) to find the right type for the array.

Why is getLength a method of Array but getComponentType a method of Class? We don't know the distribution of the reflection methods seems a bit ad hoc at times.

Here's the code:

static Object goodArrayGrow(Object a) // useful { Class cl = a.getClass(); if (!cl.isArray()) return null; Class componentType = cl.getComponentType(); int length = Array.getLength(a); int newLength = length * 11 / 10 + 10; Object newArray = Array.newInstance(componentType, newLength); System.arraycopy(a, 0, newArray, 0, length); return newArray; }

Note that this arrayGrow method can be used to grow arrays of any type, not just arrays of objects.

int[] a = { 1, 2, 3, 4 }; a = (int[]) goodArrayGrow(a);

To make this possible, the parameter of goodArrayGrow is declared to be of type Object, not an array of objects (Object[]). The integer array type int[] can be converted to an Object, but not to an array of objects!

Example 5-7 shows both array grow methods in action. Note that the cast of the return value of badArrayGrow will throw an exception.

Example 5-7. ArrayGrowTest.java

1. import java.lang.reflect.*; 2. import java.util.*; 3. 4. public class ArrayGrowTest 5. { 6. public static void main(String[] args) 7. { 8. int[] a = { 1, 2, 3 }; 9. a = (int[]) goodArrayGrow(a); 10. arrayPrint(a); 11. 12. String[] b = { "Tom", "Dick", "Harry" }; 13. b = (String[]) goodArrayGrow(b); 14. arrayPrint(b); 15. 16. System.out.println("The following call will generate an exception."); 17. b = (String[]) badArrayGrow(b); 18. } 19. 20. /** 21. This method attempts to grow an array by allocating a 22. new array and copying all elements. 23. @param a the array to grow 24. @return a larger array that contains all elements of a. 25. However, the returned array has type Object[], not 26. the same type as a 27. */ 28. static Object[] badArrayGrow(Object[] a) 29. { 30. int newLength = a.length * 11 / 10 + 10; 31. Object[] newArray = new Object[newLength]; 32. System.arraycopy(a, 0, newArray, 0, a.length); 33. return newArray; 34. } 35. 36. /** 37. This method grows an array by allocating a 38. new array of the same type and copying all elements. 39. @param a the array to grow. This can be an object array 40. or a fundamental type array 41. @return a larger array that contains all elements of a. 42. 43. */ 44. static Object goodArrayGrow(Object a) 45. { 46. Class cl = a.getClass(); 47. if (!cl.isArray()) return null; 48. Class componentType = cl.getComponentType(); 49. int length = Array.getLength(a); 50. int newLength = length * 11 / 10 + 10; 51. 52. Object newArray = Array.newInstance(componentType, newLength); 53. System.arraycopy(a, 0, newArray, 0, length); 54. return newArray; 55. } 56. 57. /** 58. A convenience method to print all elements in an array 59. @param a the array to print. can be an object array 60. or a fundamental type array 61. */ 62. static void arrayPrint(Object a) 63. { 64. Class cl = a.getClass(); 65. if (!cl.isArray()) return; 66. Class componentType = cl.getComponentType(); 67. int length = Array.getLength(a); 68. System.out.print(componentType.getName() 69. + "[" + length + "] = { "); 70. for (int i = 0; i < Array.getLength(a); i++) 71. System.out.print(Array.get(a, i) + " "); 72. System.out.println("}"); 73. } 74. }

java.lang.reflect.Array 1.1

• static Object get(Object array, int index)

• static xxx getXxx(Object array, int index)

  (xxx is one of the primitive types boolean, byte, char, double, float, int, long, short.) These methods return the value of the given array that is stored at the given index.

• static void set(Object array, int index, Object newValue)

• static setXxx(Object array, int index, xxx newValue)

  (xxx is one of the primitive types boolean, byte, char, double, float, int, long, short.) These methods store a new value into the given array at the given index.

• static int getLength(Object array)

  returns the length of the given array.

• static Object newInstance(Class componentType, int length)

• static Object newInstance(Class componentType, int[] lengths)

  return a new array of the given component type with the given dimensions.

Method Pointers!

On the surface, Java does not have method pointers ways of giving the location of a method to another method so that the second method can invoke it later. In fact, the designers of Java have said that method pointers are dangerous and error prone and that Java interfaces (discussed in the next chapter) are a superior solution. However, it turns out that, as of JDK 1.1, Java does have method pointers, as a (perhaps accidental) by-product of the reflection package.

NOTE

To see method pointers at work, recall that you can inspect a field of an object with the get method of the Field class. Similarly, the Method class has an invoke method that lets you call the method that is wrapped in the current Method object. The signature for the invoke method is

Object invoke(Object obj, Object... args)

The first parameter is the implicit parameter, and the remaining objects provide the explicit parameters. (Before JDK 5.0, you had to pass an array of objects or null if the method has no explicit parameters.)

For a static method, the first parameter is ignored you can set it to null.

For example, if m1 represents the getName method of the Employee class, the following code shows how you can call it:

String n = (String) m1.invoke(harry);

As with the get and set methods of the Field type, there's a problem if the parameter or return type is not a class but a primitive type. You either rely on autoboxing or, before JDK 5.0, wrap primitive types into their corresponding wrappers.

Conversely, if the return type is a primitive type, the invoke method will return the wrapper type instead. For example, suppose that m2 represents the getSalary method of the Employee class. Then, the returned object is actually a Double, and you must cast it accordingly. As of JDK 5.0, automatic unboxing takes care of the rest.

double s = (Double) m2.invoke(harry);

How do you obtain a Method object? You can, of course, call getdeclaredMethods and search through the returned array of Method objects until you find the method that you want. Or, you can call the getMethod method of the Class class. This is similar to the getField method that takes a string with the field name and returns a Field object. However, there may be several methods with the same name, so you need to be careful that you get the right one. For that reason, you must also supply the parameter types of the desired method. The signature of getMethod is

Method getMethod(String name, Class... parameterTypes)

For example, here is how you can get method pointers to the getName and raiseSalary methods of the Employee class.

Method m1 = Employee.class.getMethod("getName"); Method m2 = Employee.class.getMethod("raiseSalary", double.class);

(Before JDK 5.0, you had to package the Class objects into an array or to supply null if there were no parameters.)

Now that you have seen the rules for using Method objects, let's put them to work. Example 5-8 is a program that prints a table of values for a mathematical function such as Math.sqrt or Math.sin. The printout looks like this:

public static native double java.lang.Math.sqrt(double) 1.0000 | 1.0000 2.0000 | 1.4142 3.0000 | 1.7321 4.0000 | 2.0000 5.0000 | 2.2361 6.0000 | 2.4495 7.0000 | 2.6458 8.0000 | 2.8284 9.0000 | 3.0000 10.0000 | 3.1623

The code for printing a table is, of course, independent of the actual function that is being tabulated.

double dx = (to - from) / (n - 1); for (double x = from; x <= to; x += dx) { double y = (Double) f.invoke(null, x); System.out.printf("%10.4f | %10.4f%n" + y, x, y); }

Here, f is an object of type Method. The first parameter of invoke is null because we are calling a static method.

To tabulate the Math.sqrt function, we set f to

Math.class.getMethod("sqrt", double.class)

That is the method of the Math class that has the name sqrt and a single parameter of type double.

Example 5-8 shows the complete code of the generic tabulator and a couple of test runs.

Example 5-8. MethodPointerTest.java

1. import java.lang.reflect.*; 2. 3. public class MethodPointerTest 4. { 5. public static void main(String[] args) throws Exception 6. { 7. // get method pointers to the square and sqrt methods 8. Method square = MethodPointerTest.class.getMethod("square", 9. double.class); 10. Method sqrt = Math.class.getMethod("sqrt", double.class); 11. 12. // print tables of x- and y-values 13. 14. printTable(1, 10, 10, square); 15. printTable(1, 10, 10, sqrt); 16. } 17. 18. /** 19. Returns the square of a number 20. @param x a number 21. @return x squared 22. */ 23. public static double square(double x) 24. { 25. return x * x; 26. } 27. 28. /** 29. Prints a table with x- and y-values for a method 30. @param from the lower bound for the x-values 31. @param to the upper bound for the x-values 32. @param n the number of rows in the table 33. @param f a method with a double parameter and double 34. return value 35. */ 36. public static void printTable(double from, double to, 37. int n, Method f) 38. { 39. // print out the method as table header 40. System.out.println(f); 41. 42. // construct formatter to print with 4 digits precision 43. 44. double dx = (to - from) / (n - 1); 45. 46. for (double x = from; x <= to; x += dx) 47. { 48. try 49. { 50. double y = (Double) f.invoke(null, x); 51. System.out.printf("%10.4f | %10.4f%n", x, y); 52. } 53. catch (Exception e) { e.printStackTrace(); } 54. } 55. } 56. }

As this example shows clearly, you can do anything with Method objects that you can do with function pointers in C (or delegates in C#). Just as in C, this style of programming is usually quite inconvenient and always error prone. What happens if you invoke a method with the wrong parameters? The invoke method throws an exception.

Also, the parameters and return values of invoke are necessarily of type Object. That means you must cast back and forth a lot. As a result, the compiler is deprived of the chance to check your code. Therefore, errors surface only during testing, when they are more tedious to find and fix. Moreover, code that uses reflection to get at method pointers is significantly slower than code that simply calls methods directly.

For that reason, we suggest that you use Method objects in your own programs only when absolutely necessary. Using interfaces and inner classes (the subject of the next chapter) is almost always a better idea. In particular, we echo the developers of Java and suggest not using Method objects for callback functions. Using interfaces for the callbacks (see the next chapter as well) leads to code that runs faster and is a lot more maintainable.

java.lang.reflect.Method 1.1

• public Object invoke(Object implicitParameter, Object[] explicitParameters)

  invokes the method described by this object, passing the given parameters and returning the value that the method returns. For static methods, pass null as the implicit parameter. Pass primitive type values by using wrappers. Primitive type return values must be unwrapped.