CSC/ECE 517 Fall 2011/ch4 4f ss: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
(Created page with "== Reflection == Reflection allows program entities to discover things about themselves through introspection. In other words,Reflection is the ability of a program to deter...")
 
No edit summary
Line 8: Line 8:
The information may include the following :
The information may include the following :


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


Reflection is supported by many  [http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming]languages in various forms. Powerful and flexible reflection mechanisms are exhibited by  [http://www.smalltalk.org/main/ Smalltalk],  [http://www.ruby-lang.org/en/Ruby], and [http://www.python.org/ Python] .  [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] also supports reflection. But reflection in java is verbose and is not as flexible and dynamic as these languages. [http://www.cplusplus.com/doc/tutorial/ 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. [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] also has support for a limited form of reflection which  includes the ability to determine the features contained in an object.  
Reflection is supported by many  [http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming]languages in various forms. Powerful and flexible reflection mechanisms are exhibited by  [http://www.smalltalk.org/main/ Smalltalk],  [http://www.ruby-lang.org/en/Ruby], and [http://www.python.org/ Python] .  [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] also supports reflection. But reflection in java is verbose and is not as flexible and dynamic as these languages. [http://www.cplusplus.com/doc/tutorial/ 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. [http://en.wikipedia.org/wiki/Eiffel_(programming_language) 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 ==
== Reflection in Ruby ==
== 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)
<pre>String myStr = "HelloWorld";
Class theClass = myStr.getClass(); // 'theClass' now contains 'String'
</pre>
The property ".class"(available for every java class) returns a Class object for the class.
<pre>
String myStr = "HelloWorld";
if (myStr.getClass()==String.class)
System.out.println("The object is a String"); // prints "The object is a String"
</pre>
The wrapper classes (Integer, Boolean, Double,...) contain a ".TYPE" property that returns the Class object representing the primitive type.
<pre>
Class myClass = Integer.TYPE; //
</pre>
'''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
<pre>
  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);
          }
      }
  }
</pre>
The output of the program is:
<pre>
  name = i
  decl class = MyfieldClass
  type = double
 
  name = s
  decl class = MyfieldClass
  type = class java.lang.String
 
 
</pre>
'''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.
<pre>
  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);
        }
      }
  }
</pre>
The output of the program is:
<pre>
  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
 
</pre>
'''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
<pre>
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);
          }
      }
  }
</pre>
output:
<pre>
Name=MyConstructor
Declaring Class name=MyConstructor
</pre>
 
'''Applications of Reflection in Java''':Many sophisticated Java applications rely on reflection
* Reflection is used extensively in protocols like  [http://www.w3schools.com/soap/soap_intro.asp SOAP]
*Whenever we  drag-and-drop an object in an  [http://en.wikipedia.org/wiki/Integrated_development_environment 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  [http://www.linfo.org/robust.html 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/

Revision as of 19:06, 18 October 2011

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

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/