CSC/ECE 517 Fall 2010/ch3 1c AE

Reflective Language Features vs. Reflective Packages

Definition

Reflection is the integral quality of a program to dynamically manipulate its own state. (i.e.,) the program can infer and modify itself by making use of its representation of its own self-accessible state(implementation, structure and all aspects). The program takes itself as its domain to be acted upon. It contains metadata and associated operations to manipulate the metadata in runtime. Programming languages that possess this quality are said to be reflective.

Eg :

A reflective system shall allow programmers to create new metalevel objects and selectively substitute them for an existing part of the running system.

Reflection is a valuable language feature to facilitate metaprogramming. Reflection is defined as the ability of a programming language to be its own meta-language. Thus, reflection is writing programs that manipulate other programs or themselves. [5] e.g. In Java, reflection enables to discover information about the loaded classes: Fields, Methods and constructors Generics information Metadata annotations

It also enables to use these metaobjects to their instances in run time environment. E.g. Method.invoke(Object o, Object… args) With the Java reflection API, you can interrogate an object to get all sorts of information about its class. Consider the following simple example: public class HelloWorld {

  public void printName() {
     System.out.println(this.getClass().getName());
  }

} The line (new HelloWorld()).printName(); sends the string HelloWorld to standard out. Now let x be an instance of HelloWorld or one of its subclasses. The line x.printName(); sends the string naming the class to standard out.

The printName method examines the object for its class (this.getClass()). In doing so, the decision of what to print is made by delegating to the object's class. The method acts on this decision by printing the returned name. Without being overridden, the printName method behaves differently for each subclass than it does for HelloWorld. The printName method is flexible; it adapts to the class that inherits it, causing the change in behavior.

This small example is more dramatic than it seems—it contains each of the steps previously mentioned. The printName method examines the object for its class (this.getClass()). In doing so, the decision of what to print is made by delegating to the object's class. The method acts on this decision by printing the returned name. Without being overridden, the printName method behaves differently for each subclass than it does for HelloWorld. The printName method is flexible; it adapts to the class that inherits it, causing the change in behavior. As we build our examples in scope and complexity, we will show you many more ways to attain flexibility using reflection.

Reflective mechanisms

Types of reflection like introspection, intercession, structural & behavioral -- Reflection at Different Stages of the Program Lifecycle

Reflective languages

Languages like LISP, CLOS, etc

Reflection in OO like JAVA

OO-languages (java ‘s reflex package, C#’s, C++’s, etc)

References

http://www.springerlink.com/content/6l63883r9224q186/ http://www.cs.indiana.edu/~jsobel/rop.html http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-272.pdf http://www.di.uniovi.es/ooosws2001/papers/ortin_final.pdf http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html http://scg.unibe.ch/archive/papers/Duca06dMOOSEMODELS2006.pdf file:///C:/Users/Summer/Downloads/10.1.1.158.2012.pdf - good link .. http://www.ub.uni-konstanz.de/kops/volltexte/2002/803/pdf/DissertationEgbertAlthammer.pdf http://www.laputan.org/reflection/ooffrmla.html