CSC/ECE 517 Fall 2011/ch4 4f ss

Reflection

Reflection allows program entities to discover things about themselves through introspection.

In other words,Reflection is the ability of a program to determine information about an object at runtime.

The information may include the following :

• The type of the object
• Inheritance structure
• Methods it contains.
• Number of parameters of the methods,types of parameters, return types.
• Names and types of the attributes of the object.

Reflection is supported by many Object-oriented programminglanguages in various forms. Powerful and flexible reflection mechanisms are exhibited by Smalltalk, [1], and Python . Java also supports reflection. But reflection in java is verbose and is not as flexible and dynamic as these languages. C++ allows a program to determine the type of an object at run-time. Thus it does support reflection but in a limited form only. Eiffel also has support for a limited form of reflection which includes the ability to determine the features contained in an object.

Reflection in Ruby

Examples of reflection in ruby :

puts "hello".class  #returns the class of object "hello" 

Output:

String

puts "hello".class.superclass  #returns the superclass of the String class

Output:

Object

puts string.ancestors #returns the ancestors of the string class

String

Comparable Object Basic Object Kernel

Obtaining Reference to a

Reflection in Java

Reflection in Java is much more verbose than in ruby.It is an advanced feature of the Java environment. Reflection is achieved using the Reflection API.The verbosity of reflection in java may be associated with the usage of the library for reflection.

Big industrial-strength protocols like SOAP and JavaBeans wouldn't be possible if it weren't for Reflection. Every time you drag-and-drop an object in your favorite IDE into a form, Reflection is orchestrating the action behind the scenes. Actually, most sophisticated Java applications rely on Reflection in one way or another.

Reflection is an advanced feature of the Java environment. It gives runtime information about objects, classes, and interfaces. Some of the questions that can be answered using reflection in java:

*   Which class does an object belong to?
*   What is the description of a given class name?
*   What are the fields in a given class?
*   What is the type of a field?
*   What are the methods in a class?
*   What are the parameters of a method?
*   What are the constructors of a given class? 
*   Constructing an object using a given constructor
*   Invoking an object's method using such-and-such parameters
*   Assigning a value to an object's field
*   Dynamically creating and manipulating arrays  

Java Reflection Classes

All Reflection classes (With the exception of the class Class that resides in the default Java package) are contained in the package java.lang.reflect.

Following are some of the classes used to various represent members of a class.: Classes-'Class' class Fields-'Field' class methods-'Method' class constructors-'Constructor' class arrays-'Array' class.

Illustration of Reflection in Java through Examples

Class

Each class or interface in Java is described by a Class object.It contains methods to obtain details about the class like name, parent class, constructors, fields, methods, interfaces implemented etc.

To obtain the class that an object belongs to, invoke the method Class getClass()(returns 'Class') of the 'Object' class (superclass of all the Java classes hierarchy)

String myStr = "HelloWorld";
Class theClass = myStr.getClass(); // 'theClass' now contains 'String'

The property ".class"(available for every java class) returns a Class object for the class.

String myStr = "HelloWorld";
if (myStr.getClass()==String.class)
System.out.println("The object is a String"); // prints "The object is a String"

The wrapper classes (Integer, Boolean, Double,...) contain a ".TYPE" property that returns the Class object representing the primitive type.

Class myClass = Integer.TYPE; //

Field

The Field class describes the different attributes of a Java class field. Information such as a field name, its type, and its accessibility can be obtained from a field object. It also contains methods to set and get the field's value for a given object Example

   import java.lang.reflect.*;
        
   public class MyfieldClass {
      int i = 100;
      String s = "Hello World";
        
      public static void main(String args[])
      {
         try {
            Class cls = Class.forName("MyfieldClass");
        
            Field flist[]= cls.getDeclaredFields();
            for (int i = 0; i < flist.length; i++) {
              
               Field f = flist[i];
               System.out.println("name
                  = " + f.getName());
               System.out.println("decl class = " +
                           f.getDeclaringClass());
               System.out.println("type
                  = " + f.getType());
               
            }
          }
          catch (Throwable e) {
             System.err.println(e);
          }
       }
   }

The output of the program is:

  name = i
   decl class = MyfieldClass
   type = double
   
   name = s
   decl class = MyfieldClass
   type = class java.lang.String
   
  

Method

The Method class is used to obtain information(the method name, its type, its accessibility, and its parameter types) about class methods.We can even invoke the method on a particular object and pass a set of parameters to it.

   import java.lang.reflect.*;

   public class myMethodClass {
      private int myMethod(int y, int x) 
      {
         return x+y;
      }
        
      public static void main(String args[])
      {
         try {
           Class cls = Class.forName("myMethodClass");
        
            Method mlist[] = cls.getDeclaredMethods();
            
              for (int i = 0; i < mlist.length;i++) 
              {  
               Method m = mlist[i];
               System.out.println("name= " + m.getName());
               System.out.println("decl class = " +m.getDeclaringClass());
                              
               Class pt[] = m.getParameterTypes();
               for (int j = 0; j < pt.length; j++)
                  System.out.println("param #" + j + " " + pt[j]);
                   
              
               System.out.println("return type = " +
                                  m.getReturnType());
               
            }
         }
         catch (Throwable e) {
            System.err.println(e);
         }
      }
   }

The output of the program is:

  name = myMethod
   decl class = class myMethodClass
   param #0 int
   param #1 int
   
   return type = int
   
   name = main
   decl class = class myMethodClass
   param #0 class [Ljava.lang.String;
   return type = void
   

Constructor

The Constructor class can be used to obtain information(parameter types, number of parameters, and accessibility) about class constructors.We can also invoke the constructor to create new object instances

 import java.lang.reflect.*;
        
   public class Myconstructor {
      public Myconstructor()
      {
      }
        
     public static void main(String args[])
      {
         try {
           Class c = Class.forName("Myconstructor");
        
           Constructor clist[]= c.getDeclaredConstructors();
         
           for (int i = 0; i < clist.length; i++) {
               Constructor ct = clist[i];
               System.out.println("name= " + ct.getName());
               System.out.println("Declaring Class Name = " +
                            ct.getDeclaringClass());
               Class pTypes[] = ct.getParameterTypes();
               for (int j = 0; j <  pTypes.length; j++)
                  System.out.println("param #" 
                     + j + " " +  pTypes[j]);
               
              
            }
          }
          catch (Throwable e) {
             System.err.println(e);
          }
      }
   }

output:

Name=MyConstructor
Declaring Class name=MyConstructor

Applications of Reflection in Java:Many sophisticated Java applications rely on reflection

• Reflection is used extensively in protocols like SOAP
• Whenever we drag-and-drop an object in an IDE to use it in a form, Reflection is used behind the scenes.
• Java Beans
• It is used in Debuggers and Test Tools which require examining the private members <ref>http://download.oracle.com/javase/tutorial/reflect/</ref>.
• It is used class browser which needs to be able to enumerate the members of classes.
• It is also employed in Visual development environments. The type information available in reflection is used to help the developer in writing correct code.

Benefits

• Reflection helps in keeping software robust
• It helps in making the applications more flexible,extensible and pluggable.
• It helps in making the source code more readable.
• It can simplify source code and design.
• Expensive conditional code can be reduced/removed.

See more: http://download.oracle.com/javase/tutorial/reflect/