CSc 305 Talk Summary Template

• Reflection is made possible in java by use of the java.lang.reflect package
• Reflection is also an important part of the JavaBeans component model.
• The Class object is one of the most important objects in the implementation of reflection. This extends the Object class.
• Some useful methods of Class object:
• forName(String className) : This will return the Class object of the interpreted string
• getClasses() : Returns an array containing Class objects representing all the public classes and interfaces that are members of the class represented by this Class object.
• getDeclaredMethods() : This will return all methods of the Class declared within the class
• isInstance(Object o) : This will determine if the calling's class is equivalent to the Class type of the given object
• Description: Provides classes and interfaces for obtaining reflective information about classes and objects.
• Example:
  

  	   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);
  	         }
  	      }
  	   }	
  	

  
  For a call at prompt such as: java DumpMethods java.util.Stack
  This would output

  	   public java.lang.Object java.util.Stack.push(
  	    java.lang.Object)
  	   public synchronized 
  	     java.lang.Object java.util.Stack.pop()
  	   public synchronized
  	      java.lang.Object java.util.Stack.peek()
  	   public boolean java.util.Stack.empty()
  	   public synchronized 
  	     int java.util.Stack.search(java.lang.Object)
  	 

• To use the classes used in Reflect, i.e. Method, there are 3 major steps required
• Step 1:
  The first step is to obtain a java.lang.Class object for the class that you want to manipulate. java.lang.Class is used to represent classes and interfaces in a running Java program.
• Step 2:
  The second step is to call a method such as getDeclaredMethods, to get a list of all the methods declared by the class.
• Step 3:
  The third step is to use the reflection API to manipulate the information.
  

  	   Class c = Class.forName("java.lang.String");
  	   Method m[] = c.getDeclaredMethods();
  	   System.out.println(m[0].toString());
  			

• So far the methods and techniques presented have only been used to get information about the Classes and the underlying methods ... etc. However one of the biggest benefits of Reflection is the ability to call methods of a class.
  Here is an example of how one can call a method of a given Class object.

  	  	   import java.lang.reflect.*;
  		   public class method2 {
  		      public int add(int a, int b)
  		      {
  		         return a + b;
  		      }
  		        
  		      public static void main(String args[])
  		      {
  		         try {
  		           Class cls = Class.forName("method2");
  		           Class partypes[] = new Class[2];
  		            partypes[0] = Integer.TYPE;
  		            partypes[1] = Integer.TYPE;
  		            Method meth = cls.getMethod(
  		              "add", partypes);
  		            method2 methobj = new method2();
  		            Object arglist[] = new Object[2];
  		            arglist[0] = new Integer(37);
  		            arglist[1] = new Integer(47);
  		            Object retobj 
  		              = meth.invoke(methobj, arglist);
  		            Integer retval = (Integer)retobj;
  		            System.out.println(retval.intValue());
  		         }
  		         catch (Throwable e) {
  		            System.err.println(e);
  		         }
  		      }
  		   }
  	  

• The last important concept I will cover is the ability to inspect objects. This is essentially the ability to look up the fields inside an object as a program runs and change them at your leisure. One nifty feature, which happens to be a huge security flaw as well, is the ability to override the private access of fields and allow the user to change whats inside. Here is an example of such a technique.
  • Here is a snipet of code to allow access to a field. To do so call its setAccessible method.
    

      		Class c = obj.getClass();
    		Field f = c.getDeclaredField(name);
    		f.setAccessible(true);
    		  	

  • If granted access one can read or write to these fields using such an example:
    

    		Object value = f.get(obj);
    		f.set(obj, value);
    			

  • If the field type is a primitive type, then the get method returns a wrapper object. Conversely, the set method expects a wrapper object and unwraps it.