There are two examples of specialized solutions to this class of problem in the 1.0 version of Java: Java applets and the command-line version of the Java interpreter. The challenge of supporting an anonymous class can be stated like this: 'Write a program that, when given a Java object, can incorporate that object into its continuing operation.' The general solution is rather difficult, but by constraining the problem, some specialized solutions can be created. Supporting anonymous classes is hard to explain and even harder to design for in a program. In this context, an anonymous class is one that is loaded or presented to a Java class at run time and whose type was previously unknown to the Java program. What has not been very dynamic historically is the ability to manipulate 'anonymous' classes. Classes are loaded dynamically, binding is done dynamically, and object instances are created dynamically on the fly when they are needed. One of Java's strengths is that it was designed with the assumption that the environment in which it was running would be changing dynamically. This month I'll take a look at the Java Reflection API, which gives Java classes the ability to perform dynamic introspection: the ability to look inside classes that are already loaded. That example is a form of static introspection. Further, I showed that with the addition of a class loader, those classes could be loaded into the running environment and executed. In last month's 'Java In-Depth,' I talked about introspection and ways in which a Java class with access to raw class data could look 'inside' a class and figure out how the class was constructed.

Java reflection get method