Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T03:48:13Z

Svontel: /* Illustration of Reflection in Java through Examples */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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.

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 [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html java.lang.reflect].

Following are some of the classes used to various represent members of a class.:
Classes-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html 'Class']

class Fields-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Field.html 'Field'] class

methods-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html 'Method'] class

constructors-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Constructor.html 'Constructor'] class

arrays-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Array.html '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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T03:34:23Z

Svontel: /* Illustration of Reflection in Java through Examples */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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.

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 [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html java.lang.reflect].

Following are some of the classes used to various represent members of a class.:
Classes-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html 'Class']

class Fields-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Field.html 'Field'] class

methods-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html 'Method'] class

constructors-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Constructor.html 'Constructor'] class

arrays-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Array.html '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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T03:13:07Z

Svontel: /* Reflection in Java */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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.

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 [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html java.lang.reflect].

Following are some of the classes used to various represent members of a class.:
Classes-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html 'Class']

class Fields-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Field.html 'Field'] class

methods-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html 'Method'] class

constructors-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Constructor.html 'Constructor'] class

arrays-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Array.html '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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T03:09:50Z

Svontel: /* Reflection in Java */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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.

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 [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html java.lang.reflect].

Following are some of the classes used to various represent members of a class.:
Classes-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html 'Class']
class Fields-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Field.html 'Field'] class
methods-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html 'Method'] class
constructors-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Constructor.html 'Constructor'] class
arrays-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Array.html '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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T03:07:45Z

Svontel: /* Reflection in Java */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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.

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 [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html java.lang.reflect].

Following are some of the classes used to various represent members of a class.:
Classes-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html 'Class']
class Fields-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Field.html 'Field'] class
methods-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html 'Method'] class
constructors-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Constructor.html 'Constructor'] class
arrays-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Array.html '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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T03:03:41Z

Svontel: /* Reflection in Java */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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.

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 [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html java.lang.reflect].

Following are some of the classes used to various represent members of a class.:
Classes-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html 'Class']
class Fields-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Field.html 'Field'] class
methods-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Method.html 'Method'] class
constructors-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Constructor.html 'Constructor'] class
arrays-[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Array.html '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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T02:55:02Z

Svontel: /* Applications of Reflection in Java */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection<ref>http://java.sys-con.com/node/36688</ref>==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T02:52:01Z

Svontel: /* Advantages of Reflection */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection<ref>http://java.sys-con.com/node/36688<ref>==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T02:06:18Z

Svontel: /* Intercepting calls to undefined methods */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_object.html#Object.method_missing method_missing]within the class definition provides this facility. This feature is not available in java.A class cast [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Exception.html exception] is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T01:57:49Z

Svontel: /* Reflection in Ruby */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie <object>''.methods'' gives the list of methods. This is in contrast to reflection in java which is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).Using Reflection,we can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
=>String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
=>Object</pre>

Example 3:
<pre>
puts 100.class # print the class of 100
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer #
>> true
puts 123456789012345.instance_of? Integer #
>> false
puts 123456789012345.instance_of? Bignum
>> true

#instance_of? is a method of Object.returns true if the object is an instance of the #given class

</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum<ref>http://ruby-doc.org/core-1.9.2/Fixnum.html</ref> stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum<ref>http://ruby-doc.org/core-1.9.2/Bignum.html</ref> objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a [http://en.wikipedia.org/wiki/Primitive_data_type primitive] and [http://en.wikipedia.org/wiki/Reference_type reference]with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.In contrast to Fixnum objects, objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

[http://ruby-doc.org/core-1.9.2/Comparable.html '''Comparable'''] which is an ancestor of the [http://ruby-doc.org/core-1.9.2/String.html String] class is a [http://en.wikipedia.org/wiki/Mixin mixin] .It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

[http://ruby-doc.org/core-1.9.2/Object.html '''Object'''] is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

[http://ruby-doc.org/core-1.9.2/BasicObject.html '''Basic Object'''] is the parent class of all classes in ruby including Object class. It is an explicit blank class.

[http://ruby-doc.org/core-1.9.2/Kernel.html '''Kernel'''] is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

[http://ruby-doc.org/core-1.9.2/Integer.html '''Integer''']is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

[http://ruby-doc.org/core-1.9.2/Numeric.html '''Numeric'''] is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

'''Comparable''' which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

'''Note''': It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end
#this is not a good practice.Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say ,size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the super class of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method(as a symbol) has to be passed as a parameter to 'method'
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,a reference to the method upcase of the String class is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference(m) can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol. Thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.

example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol
332648 # yielded same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

[http://en.wikipedia.org/wiki/Numerical_integration'''Quadrature integration''']
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into 'n' small rectangles with the heights parallel to the y axis.ie The length a to b is divided into n intervals.The area of each rectangle can be obtained by multiplying the height and the width.Height is the average of the values of f(x) at the two end points of the interval.Width is the length of the interval . Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define a method poly for the Float class which returns the evaluation of the polynomial at that point.

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
<pre>area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the #points x=10 to x=20.
</pre>

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. This feature is not available in java.A class cast exception is thrown whenever a call to an undefined method is made. Ruby passes the name of the method called(which is unavailable) and the arguments passed to it as parameters to the method_missing method .

Example : In the following example, class Duck defines 'quack' and 'method_missing' methods. When an object d of Duck is created and quack is invoked on it,it executes the quack of Duck(as expected). But when 'bark' is invoked on it, method_missing is invoked.
<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args) #handles calls to undefined methods
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark #bark is passed to method_missing since 'bark' method is not defined in Duck class.
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we invoke method XV on r (ie r.XV) ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase, split into an array and the array is reversed. The inject operator then passes each element (of the array) and an accumulator value (memo)to the block.The initial value of memo is 0. For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-20T00:31:40Z

Svontel: /* Reflection */

Introduction

Here we mainly focus on the lecture 11 of CSC 517 which is Reflection in Ruby. We also cover additional information on Reflection in Java, advantages,disadvantages of Reflection
== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3: Let us now consider the example as discussed in the class:
<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,the reference to the method upcase of the string is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into small rectangles with the lengths parallel to the y axis.The area of the rectangle can be obtained by multiplying the height and the breadth.Height is the average of the values of f(x) at the two vertices.Breadth is the distance between the two vertices. Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

Example: Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.
Then we can define

<pre>
class Float
def poly
self*self + 2*self + 3
end
end
</pre>

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the points x=10 to x=20.

To do this, we pick an interval, say (20−10)/100 = 1/10, and evaluate the polynomial for values between 10 and 20 at intervals of 1/10, e.g., 10, 10.1, 10.2, … , 19.9, 20.0. We take the value of the polynomial at 2 successive points, average these two values(height of rectangle), and multiply by 1/10 (the distance between the two points ie the width). After we do this for all 100 intervals and add up the areas, we obtain an approximation of the area under the curve.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. This feature is not available in java as a class cast exception is thrown whenever an a call to an undefined method is made. Ruby passes as parameters the name of the method called and the arguments passed to it.

<pre>
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark
</pre>

'''Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we do r.XV ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase,split into an array and the array is reversed. The inject operator then passes each element in the array and an accumulator value (memo)to the block.The initial value of memo For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T23:52:45Z

Svontel: /* Intercepting calls to undefined methods */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3: Let us now consider the example as discussed in the class:
<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,the reference to the method upcase of the string is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into small rectangles with the lengths parallel to the y axis.The area of the rectangle can be obtained by multiplying the height and the breadth.Height is the average of the values of f(x) at the two vertices.Breadth is the distance between the two vertices. Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

e.g.Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the points x=10 to x=20.

To do this, we pick an interval, say (20−10)/100 = 1/10, and evaluate the polynomial for values between 10 and 20 at intervals of 1/10, e.g., 10, 10.1, 10.2, … , 19.9, 20.0. We take the value of the polynomial at 2 successive points, average these two values(height of rectangle), and multiply by 1/10 (the distance between the two points ie the width). After we do this for all 100 intervals and add up the areas, we obtain an approximation of the area under the curve.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. This feature is not available in java as a class cast exception is thrown whenever an a call to an undefined method is made. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark
'''
Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we do r.XV ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase,split into an array and the array is reversed. The inject operator then passes each element in the array and an accumulator value (memo)to the block.The initial value of memo For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T23:51:51Z

Svontel: /* Applications of passing methods as parameters */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3: Let us now consider the example as discussed in the class:
<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

'''Difference between Fixnum and Bignum in Ruby'''

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 4:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example.

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

Example:
<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in Ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.

Example:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,the reference to the method upcase of the string is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''
Here we compute the area under a curve say f(x) between two points say 'a' and 'b' by dividing the region under the curve into small rectangles with the lengths parallel to the y axis.The area of the rectangle can be obtained by multiplying the height and the breadth.Height is the average of the values of f(x) at the two vertices.Breadth is the distance between the two vertices. Sum of the areas of all the rectangles gives us an approximation of the area of the area under f(x).

e.g.Suppose we need to compute the area under a curve described by some function, x2 + 2x + 3 between say 10 and 20.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,end points between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the points x=10 to x=20.

To do this, we pick an interval, say (20−10)/100 = 1/10, and evaluate the polynomial for values between 10 and 20 at intervals of 1/10, e.g., 10, 10.1, 10.2, … , 19.9, 20.0. We take the value of the polynomial at 2 successive points, average these two values(height of rectangle), and multiply by 1/10 (the distance between the two points ie the width). After we do this for all 100 intervals and add up the areas, we obtain an approximation of the area under the curve.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. This feature is not available in java as a class cast exception is thrown whenever an a call to an undefined method is made. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark
'''
Example of an interesting usage of method_missing: “Roman method_missing”.'''

<pre>
class Roman

DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}

def roman_to_integer(roman_string)
prev = nil #prev stores the previous value in roman string
roman_string.to_s.upcase.split(//).reverse.inject(0) do |memo, digit|
if digit_value = DIGITS[digit] #checks if the integer value is present in the hash
if prev && prev > digit_value
memo -= digit_value
else
memo += digit_value
end
prev = digit_value
end
memo
end
end

def method_missing(method)
str = method.id2name
roman_to_integer(str)
end
end

r=Roman.new
r.XV
Output : =>15
</pre>

In this example we declare a class Roman containing a hash called DIGITS which maps roman symbols with the corresponding integers. The class also contains the methods method_missing and roman_to_integer. When an object of Roman class( say r) is created and when we do r.XV ,method_missing(:XV) is invoked since the Roman class has no method named XV. Inside method_missing, the symbol is converted to "XV"(string) and roman_to_str("XV") is called. In roman_to_str method, the string is converted to uppercase,split into an array and the array is reversed. The inject operator then passes each element in the array and an accumulator value (memo)to the block.The initial value of memo For each element,if the previous digit_value exists and is greater than the current digit_value,the current digit_value is added to memo. Else current digit_value is subtracted from memo.The result becomes the new value for memo. At the end of the iteration, the final value of memo is the integer value of the roman string.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

==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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:39:04Z

Svontel: /* Applications of passing methods as parameters */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg:<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,the reference to the method upcase of the string is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function,
[[File:Integral as region under curve.svg|thumb]]e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:37:24Z

Svontel: /* Applications of passing methods as parameters */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg:<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,the reference to the method upcase of the string is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function,
[[File:Integral as region under curve.svg]thumb]e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:10:18Z

Svontel: /* Obtaining Reference to a method in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg:<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>
In the above example,the reference to the method upcase of the string is obtained by passing the symbol :upcase to the 'method' method of the String class. The reference can then be used to invoke the method 'upcase' on the string object.
Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:06:14Z

Svontel: /* Obtaining Reference to a method in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg:<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>

Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol and thus symbols cannot appear in the left side of an assigment.In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:04:04Z

Svontel: /* Difference between Fixnum and Bignum in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg:<pre> if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.
</pre>

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>

Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol .In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:02:52Z

Svontel:

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>

Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol .In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T21:00:44Z

Svontel: /* Examples of Reflection in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'. The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>

Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol .In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T20:59:31Z

Svontel: /* Obtaining Reference to a method in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'.The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call #returns "HELLO,WORLD"
</pre>

Note that in the above example name of the method passed as a symbol.This is because symbols are immutable and every instance of a particular symbol is the same symbol .In contrast,every instance of a particular string is a different string and hence has a different object id as seen in the example below.
example :
<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown next)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T20:51:05Z

Svontel: /* Obtaining Reference to a method in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'.The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call
</pre>

Note that in the above example name of the method passed as a symbol.Every instance of a particular symbol is the same symbol.

<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown below)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T20:50:06Z

Svontel: /* Examples of Reflection in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

'''Assignment'''
In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'.The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call
</pre>

Note that in the above example name of the method passed as a symbol.Every instance of a particular symbol is the same symbol. Every instance of a particular symbol is the same symbol.

<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown below)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T20:48:27Z

Svontel:

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'.The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call
</pre>

Note that in the above example name of the method passed as a symbol.Every instance of a particular symbol is the same symbol. Every instance of a particular symbol is the same symbol.

<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown below)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T20:46:35Z

Svontel: /* Examples of Reflection in Ruby */

== Reflection ==

[http://en.wikipedia.org/wiki/Reflection_(computer_programming) 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 [http://en.wikipedia.org/wiki/Object_(computer_science) object]
* [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance] structure
* [http://en.wikipedia.org/wiki/Method_(computer_science) Methods] it contains.
* Number of [http://en.wikipedia.org/wiki/Parameter_%28computer_science%29 parameters] of the methods,types of parameters, return types.
* Names and types of the [http://en.wikipedia.org/wiki/Attribute_(computer_science) 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://en.wikipedia.org/wiki/Ruby_(programming_language) 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 ==
In Ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.

===Examples of Reflection in Ruby===

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.

Example1:
<pre>puts "hello".class #returns the class of object "hello"

Output:
String</pre>

Example 2:
<pre>puts "hello".class.superclass #returns the superclass of the String class

Output:
Object</pre>

Example 3:
<pre>puts string.ancestors #returns the ancestors of the string class

Output:
String
Comparable
Object
Basic Object
Kernel
</pre>

Comparable which is an ancestor of the String class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the String class based on the definition of the rocket method.

Object is the superclass of all classes.Its methods are available to all classes unless explicitly overridden. It provides methods like to_s,eql? etc.

Basic Object is the parent class of all classes in ruby including Object class. It is an explicit blank class.

Kernel is a module is included by class Object(hence a mixin). Its methods are available in all Ruby objects.

<pre>
Fixnum.ancestors #returns the ancestors of Fixnum.
=> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicObject]
</pre>

Integer is the basic for Fixnum and Bignum which are two concrete classes that hold whole numbers in ruby.

Numeric is a class which is used to provide methods like abs,floor,ceil,modulo,unary +,unary - etc. ie methods which can be performed on numbers in general.

Comparable which is an ancestor of the Fixnum class is a mixin.It is used to provide the comparable functionality (operations like <,>,<=,>= etc)to the FixNum class based on the definition of the rocket method.

We have discussed the Object and BasicObject classes in the above example

Note: It is useful to print out the name of a class while debugging.A class of an object should not be tested while debugging in objected oriented programming. It is advised to use polymorphism to replace code that tests the class of an object and performs certain things.

eg: if s.kind_of? Integer then this_method else that_method end #this is not a good practice. #Should be replaced by polymorphism.

In some languages like C, C++, or Ada, an assignment statement like x = y is interpreted as copying the contents of variable y into the variable x. It is generally required that x,y should be of the same type and size. But it is allowed in certain cases when the variables are of similar types.In C++, if the sizes are different say size of x is less than the size of y there will be a loss of data during assignment.(Slicing).

Ruby exhibits dynamic binding, not static binding ie the type of the object in a variable is determined at runtime but not at compile time.
Therefore in ruby, x = y can be 'interpreted as bind x to the same object that y is bound to'.The assignment operation is implemented by copying the reference stored in y into x.

Thus in ruby,assignments physically copy references, but not the objects.

Example 4: Let us now consider the example as discussed in the class:

<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

===Difference between Fixnum and Bignum in Ruby===

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

===Obtaining Reference to a method in Ruby===

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call
</pre>

Note that in the above example name of the method passed as a symbol.Every instance of a particular symbol is the same symbol. Every instance of a particular symbol is the same symbol.

<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown below)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140
</pre>

===Applications of passing methods as parameters===

'''Quadrature integration'''

Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end

And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

===Intercepting calls to undefined methods===

Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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. Apart from the general benefits of reflection, listed below are a few which are specific to Java in general.

* 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>.
*Method can be easily invoked methods by their names, it is widely used in web, when invoking getters and setters by property names mentioned on jsp/jsf pages.

==Advantages of Reflection==

Reflection has many advantages some of which have been listed below:

* '''Extensibility Features:''' An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
* '''Class Browsers and Visual Development Environments''' A class browser will able to enumerate the members of classes and visual development environments can benefit from making use of type information available in reflection to help the developer in writing correct code.
* '''Debugging:''' Debuggers and Test Tools Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.
* Reflection helps in keeping software [http://www.linfo.org/robust.html robust]
* It helps in making the applications more flexible and pluggable.
* It helps in making the source code more readable and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

==Disadvantages of Reflection==

*'''Performance Overhead:''' Reflection involves types that are dynamically resolved due to which certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts. Hence, they should be avoided in sections of code which are called frequently in performance-sensitive applications.

*'''Security Restrictions:''' Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet in Java.

*'''Exposure of Internals:''' Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

*Compile-check features are lost. You can't be sure you're operating the right amount of parameters, their types, you even can't be sure the method you call exists.

==MetaProgramming==

The greek prefix [http://en.wikipedia.org/wiki/Meta 'Meta'] refers to knowledge about knowledge. [http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-19T04:21:00Z

Svontel:

== 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 [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 ==
In ruby, reflection is simpler because it is done using the language mechanisms ie .methods gives the list of methods. In contrast reflection as we shall see later is much more verbose because we need to use class names,method names,parameter names etc.
Examples of reflection in ruby :

<pre>
3.1419.methods #gives the list of methods of the float number.
irb(main):005:0> 3.1419.methods
=> [:to_s, :coerce, :-@, :+, :-, :*, :/, :quo, :fdiv, :%, :modulo, :divmod, :**,
:==, :===, :<=>, :>, :>=, :<, :<=, :eql?, :hash, :to_f, :abs, :magnitude, :zero
?, :to_i, :to_int, :floor, :ceil, :round, :truncate, :nan?, :infinite?, :finite?
, :numerator, :denominator, :to_r, :rationalize, :arg, :angle, :phase, :singleto
n_method_added, :i, :+@, :div, :remainder, :real?, :integer?, :nonzero?, :step,
:to_c, :real, :imaginary, :imag, :abs2, :rectangular, :rect, :polar, :conjugate,
:conj, :between?, :nil?, :=~, :!~, :class, :singleton_class, :clone, :dup, :ini
tialize_dup, :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untruste
d?, :trust, :freeze, :frozen?, :inspect, :methods, :singleton_methods, :protecte
d_methods, :private_methods, :public_methods, :instance_variables, :instance_var
iable_get, :instance_variable_set, :instance_variable_defined?, :instance_of?, :
kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?,
:extend, :display, :method, :public_method, :define_singleton_method, :__id__,
:object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exe
c, :__send__]
</pre> This is an example of discovering things about 3.1459 at runtime.(Reflection).We can act on information during runtime without compiling it in. Information needed can be found out at run-time instead of writing code at compile time.
<pre>puts "hello".class #returns the class of object "hello" </pre>

Output:
<pre>String</pre>

<pre>puts "hello".class.superclass #returns the superclass of the String class</pre>

Output:
<pre>Object</pre>

<pre>puts string.ancestors #returns the ancestors of the string class</pre>

</pre>String
Comparable
Object
Basic Object
Kernel
</pre>

MetaProgramming :

The greek prefix 'Meta' refers to knowledge about knowledge. Metaprogramming means programs can create new code at runtime and run the code that is written. Program that writes a program.The related technique of metaprogramming allows one to create new program entities, such as methods or classes, at run time.
<pre>
puts 100.class # print the class of 1
>> Fixnum
puts 98343098452405890454.class #prints the class of 98343098452405890454
>> Bignum
puts 123456789012345.kind_of? Integer
>> true
puts 123456789012345.instance_of? Integer
>> false
puts 123456789012345.instance_of? Bignum
>> true
</pre>

Difference between Fixnum and Bignum in Ruby :

A Fixnum stores Integer values which can be represented in a native machine word (minus 1 bit). If an operation on a Fixnum results in a value that exceeds the range, the value is automatically converted to a Bignum.

When Fixnum objects are assigned or passed as parameters, the actual objects are passed, rather than references to the objects. There is only one Fixnum object instance for a given integer value

Bignum objects are used to store values of integers outside the range of Fixnum. They are created automatically when encountered with integer calculations that would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

OO Languages distinguish between a primitive and reference with help of a leading or trailing bit. ie One bit indicates if the remaining bits store a primitive or a reference and the remaining bits represent the value. In numeric calculations, most of numbers are primitives so primitives can be used directly avoiding the overhead of indirection. One main difference between Fixnum and Bignum is that Fixnum can be stored in 1 machine word. If the object cannot be stored in a machine word then Bignum is used. In case of Bignum a reference to the actual object is stored.

In contrast to Fixnum objects, in case of objects references to objects are used for parameter passing.

'''Obtaining Reference to a method in ruby:'''

A reference to a method can be obtained by using the method ''method'' in the class ''Object''.
It is available to all classes, since Object is the superclass of all classes. The reference thus obtained can be used to invoke that particular method.
eg:
<pre>
str = "Hello, World"
#The name of the method has to be passed as a symbol to method:
m = str.method(:upcase) # returns a Method object which is a closure.
puts m.call
</pre>
Note that in the above example name of the method passed as a symbol.Every instance of a particular symbol is the same symbol. Every instance of a particular symbol is the same symbol.

<pre>
irb(main):009:0> puts :mysymbol.object_id
332648
=> nil
irb(main):010:0> puts :mysymbol.object_id #Note that 2 occurrences of the same symbol yielded
332648 #same object id unlike strings (shown below)
=> nil
irb(main):011:0> puts "mystring".object_id
21196488
=> nil
irb(main):012:0> puts "mystring".object_id
20959140

</pre>

application of passing methods as parameters :Quadrature integration
Suppose we need to compute the area under a curve described by some function, e.g., x2 + 2x + 3.

Then we can define
class Float
def poly
self*self + 2*self + 3
end
end
And to compute the area,we pass poly to an integration method which takes the method reference,upper bound and lower bound between which the area is to be computed as the parameters
area = integrate(:poly, 10, 20) #calculates the area of the curve x2+2x+3 between the limits x=10 to x=20.

'''
Intercepting calls to undefined methods'''
Ruby provides an option to intercept the call when a call to an undefined method is made on an object.
Implementation of the method method_missing within the class definition provides this facility. Ruby passes as parameters the name of the method called and the arguments passed to it.
class Duck
def quack
puts "Quack"
end
def method_missing(meth, *args)
puts "Sorry, I do not #{meth}"
end
end
d = Duck.new
d.quack
>>Quack
d.bark
>> Sorry, I do not bark

Example of an interesting usage of method_missing: “Roman method_missing”.

== 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 and easier to understand.
* It can simplify source code and design.
* Expensive conditional code can be reduced/removed.

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

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-18T21:33:16Z

Svontel: /* Reflection in Ruby */

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-18T19:06:38Z

Svontel:

CSC/ECE 517 Fall 2011/ch4 4f ss

2011-10-18T14:13:23Z

Svontel: 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..."

CSC/ECE 517 Fall 2011

2011-10-18T05:04:33Z

Svontel:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[CSC/ECE 517 Fall 2011/ch4 4i js]]

*[[CSC/ECE 517 Fall 2011/ch4 4f ss]]

*[[trial]]

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T03:57:28Z

Svontel: /* Singleton Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A [http://javapapers.com/core-java/explain-the-java-static-modifier/ static]modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:''' In the following example,We create a class called 'SingletonClass' . In this class,we declare a private static instance variable called 'singletonObject'.The constructor of the class is also made private.A public static accessor method ,'getSingletonObject' is defined which returns the reference to the instance of the class that is stored in the private instance variable singletonObject. Note that the object is created only the first time the accessor is called. Other invocations of the method yield the same object. Also the 'clone' method of the Object class is overridden to disallow cloning. The class 'SingletonObjectDemo' gets an instance of SingletonClass by using the public accessor method.An attempt to create an object of SingletonClass using 'new' throws compilation error as the constructor is made private.
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T03:44:00Z

Svontel: /* Singleton Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A [http://javapapers.com/core-java/explain-the-java-static-modifier/ static]modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:''' In the following example,We create a class called 'SingletonClass' .In the class,we declare a private static instance variable called 'singletonObject'.The constructor of the class is also made private.A public static accessor method ,'getSingletonObject' is defined which returns the reference to the instance of the class stored in the private instance variable singletonObject. Note that the object is created only the first time the accessor is called. Other invocations of the method yield the same object. Also the 'clone' method of the Object class is overridden to disallow cloning. The class 'SingletonObjectDemo' gets an instance of SingletonClass by using the public accessor method.An attempt to create an object of SingletonClass using 'new' throws compilation error as the constructor is made private.
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T03:37:59Z

Svontel: /* Singleton Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:''' In the following example,We create a class called 'SingletonClass' .In the class,we declare a private static instance variable called 'singletonObject'.The constructor of the class is also made private.A public static accessor method ,'getSingletonObject' is defined which returns the reference to the instance of the class stored in the private instance variable singletonObject. Note that the object is created only the first time the accessor is called. Other invocations of the method yield the same object. Also the 'clone' method of the Object class is overridden to disallow cloning. The class 'SingletonObjectDemo' gets an instance of SingletonClass by using the public accessor method.An attempt to create an object of SingletonClass using 'new' throws compilation error as the constructor is made private.
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T03:12:19Z

Svontel: /* References: */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T03:11:06Z

Svontel: /* Comparable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T03:08:17Z

Svontel:

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.

Example of Comparable behavior: Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example[[Example of Comparable behavior:]].The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T02:53:54Z

Svontel: /* Singleton Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private and providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T02:35:11Z

Svontel: /* Data Mapper */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.

<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

myrecipee.save #To insert into the DB

myrecipee.Description=’Tasty and Delicious!’ #to modify the DB

myrecipee.destroy #to delete the tuple in the database

puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T01:45:15Z

Svontel: /* Enumerable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series. For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T01:42:46Z

Svontel: /* Enumerable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
For example, to print all elements of a vector v:
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T01:39:52Z

Svontel: /* Enumerable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' Mix in Enumerable in a class as follows'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T01:38:01Z

Svontel: /* Enumerable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the 'each' method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s 'each' method yields each element.The Hash class‘s 'each' yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

*inject
One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in the string "123Bond007" are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T01:25:48Z

Svontel: /* Comparable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T01:24:05Z

Svontel: /* Comparable Behavior */

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module<ref>http://www.tutorialspoint.com/ruby/ruby_modules.htm</ref> in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences<ref>http://ruby-doc.org/</ref>:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins<ref>http://en.wikipedia.org/wiki/Mixin</ref> are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a need to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable behavior in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second) #implementation of <=>
self.revenue <=> second.revenue # we use the <=> of FixNum
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort #The elements(objects of Organisation) of the array a are sorted in the increasing order of their revenues.
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of a user-defined class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in the method to compare the two objects of that class<ref>http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html</ref>.

Consider the same scenario as in the above example.The implementation in java is as follows

Consider the same scenario as in the above example.The implementation in java is as follows.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects<ref>http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/</ref>. 
Hibernate<ref>http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html</ref> defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern<ref>http://en.wikipedia.org/wiki/Singleton_pattern</ref> is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior<ref>http://www.javabeginner.com/learn-java/java-singleton-design-pattern</ref> can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>

http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:47:55Z

Svontel:

Here we discuss about interfaces in Java, modules and mixins in Ruby.We also briefly discuss about some predefined mixin modules and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:45:20Z

Svontel: /* Some Pre-defined mixin modules */

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

Following is a brief introduction of the predefined mixin modules.

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method 'between?'.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the implementation for the method 'each'.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.

The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.

'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper<ref>http://ruby.about.com/od/sinatra/a/datamapper.htm</ref>.

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
<references/>
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:18:23Z

Svontel: /* Some Pre-defined mixin modules */

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace],[http://www.ruby-doc.org/core-1.8.7/classes/Precision.html Precision] , [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:15:58Z

Svontel: /* Some Pre-defined mixin modules */

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace], Preci-sion, [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.

'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:14:43Z

Svontel: /* Mixins */

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''Here we define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace], Preci-sion, [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern

CSC/ECE 517 Fall 2011/ch1 2c rs

2011-10-01T00:12:48Z

Svontel: /* Modules in Ruby */

Here we discuss about interfaces in Java, mixins in Ruby and compare some of the functionalities offered by mixins and the corresponding behaviors if exhibited by the interfaces.
==Interfaces in Java==
An interface in java is a collection of related methods with empty bodies, constant declarations ,nested types. It is declared using a key word ‘interface’. Constants are implicitly static and final. The methods are implicitly public, an interface cannot be instantiated as it is incomplete i.e, the methods are only declared but not defined. It can only be extended by other interfaces or implemented by [http://en.wikipedia.org/wiki/Classes_(computer_science) classes]. An interface can extend any number of interfaces.

An interface can be defined in the following manner.
<pre>
interface <interface name>
{ <constants>
<method declarations>
}
</pre>

A variable whose declared type is an interface type can hold a reference to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] of a class (or its subclass) that has implemented this interface.

'''Contractual Obligation:'''
A class that implements an interface has to provide a definition for each method of the inferface or has to be declared as an [http://en.wikipedia.org/wiki/Abstract_class abstract class] if it fails to implement even one method specified in the interface. An error message is issued by the [http://en.wikipedia.org/wiki/Compiler compiler] if the class does not define all the methods of an interface it has agreed to define. Even unrelated classes can implement an interface.

'''Example of an Interface:'''

In the following example, we create an interface called 'Shape' with the methods 'draw' and 'displayArea'. A class 'Square' implements the interface 'Shape' by provided definitions for the methods 'draw' and 'displayArea'. In the main method we create an object of Square and call the methods. Note that a 'Shape' variable can be used to hold the reference to the object of 'Square'

<pre>
interface Shape
{
void draw();
void displayArea(float a,float b);
}

class Square implements Shape
{
public void draw()
{
System.out.println("Drawing Square");
}
public void displayArea(float a,float b)
{
System.out.println("Area is "+a*b);
}
}

public class InfDemo
{
public static void main(String args[])
{ Square s=new Square();
s.draw();
s.displayArea(5,5);
}
}
</pre>
'''Output:'''

<pre>
Drawing Square
Area is 25.0
</pre>

'''Some benefits of Interfaces in Java'''
*Interfaces allow an object to play several roles.ie They can be used to simulate multiple inheritance.
*They help the developer to design the skeleton behavior for classes.
*An interface can also be used for creating a class that can store application level constants.
*Interfaces are very useful when publishing [http://en.wikipedia.org/wiki/Application_programming_interface APIs]

==Modules in Ruby==
A Module in ruby is a way of grouping together methods,variables and classes. It is similar to the idea of [http://en.wikipedia.org/wiki/Namespace_(computer_science) namespace]. A module has the same implementation and is similar to a [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Classes ruby class ] except for a few significant differences:
* Instance of a module cannot be created.
* It cannot be inherited by other classes but can be 'included'. (including a module in a class definition can roughly mean that the methods are appended to the class).
* The syntax for defining a module is different.

A module can be defined as follows :
<pre>
module <Module Name>
#define methods
#define classes
#define constants
end
</pre>

'''Example''': Consider a requirement where a person must bow to a good guy and hit the bad guy with a bow.

The module 'GoodGuy' implements a method 'bow' and tells the caller to bow to the guy because he is a good guy.
<pre>
module GoodGuy
def GoodGuy.bow
puts "I bow to you. you are a good guy"
end
end
</pre>
There is another module 'BadGuy' which implements the same method bow but tells the caller to hit the guy with a bow because he is a bad guy.
<pre>
module BadGuy
def BadGuy.bow
puts "I will hit you with a bow.you are a bad guy"
end
end
</pre>

A third program which wants to use these modules can load the files using 'require' keyword and can refer to the methods using the qualified names.
Note: A module's method can be called by <Module name>.<method name> and module constants are referred as <Module_name>::<method name>
<pre>
require 'GoodGuy' #require is used to load and execute the code once.
require 'BadGuy'
GoodGuy.bow
BadGuy.bow
</pre>

==Mixins in Ruby==
===History of Mixins===
Mixins are not something new. Smalltalk supported them way back in 1971.According to wikipedia,'' Mixins first appeared in the Symbolics' object-oriented Flavors system (developed by Howard Cannon), which was an approach to object-orientation used in Lisp Machine Lisp. The name was inspired by Steve's Ice Cream Parlor in Somerville, Massachusetts The ice cream shop owner offered a basic flavor of ice cream and blended in a combination of extra items and called the item a "Mix-in", his own trademarked term at the time .''

===Mixins===
Mixins are used to make certain behavior(s) available to a class.

Lets assume that the two modules(module 'GoodGuy'and 'BadGuy') in the above example were classes. Ruby is [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming) single-inherited], so the same functionality (ie a person must bow to a good guy and hit the bad guy with a bow). as above cannot be implemented through a class as we need to extend both the GoodGuy class and the BadGuy class which is not possible. Through modules, Ruby provides simulation of excellent feature of [http://en.wikipedia.org/wiki/Multiple_inheritance multiple inheritance]. Any functionality of any module can be imported into our class. Thus, the features of the module gets “mixed-in” with our class. 

'''Example of Mixins:'''
We now define a class to extend both the modules and call the same 'bow' method of the two modules from the object of our class.
<pre>
require 'GoodGuy'
require 'BadGuy'
class Actnow
include 'GoodGuy'
include 'BadGuy'
def Act(kind)
if(kind=='good')
GoodGuy.bow
end
if (kind =='bad')
BadGuy.bow
end
end
end

myobj=Actnow.new
myobj.Act('good')
myobj.Act('bad')

</pre>

Note:
The methods of the module do not belong to the class 'requiring' it. To make a module's method the instance methods of our class, we have to use ''include'' instead of'' require''. However, to include a module which is in a separate file, we have to use both the keywords 'require' and 'include'. This does not mean that these methods are copied into the class definition. Using 'includes <module name>' just references the module’s method from our class. Thus, any modifications made to the method definition in the module even at run time are reflected in the class.

== Some Pre-defined mixin modules ==
Ruby has the following built into modules: [http://www.ruby-doc.org/core/classes/Comparable.html Comparable], [http://www.ruby-doc.org/core/classes/Enumerable.html Enumerable],[http://ruby-doc.org/core/classes/FileTest.html FileTest], [http://www.ruby-doc.org/core/classes/GC.html GC], [http://ruby-doc.org/core/classes/Kernel.html Kernel],[http://www.ruby-doc.org/core/classes/Math.html Math], [http://ruby-doc.org/core/classes/ObjectSpace.html ObjectSpace], Preci-sion, [http://www.ruby-doc.org/core/classes/Process.html Process], [http://ruby-doc.org/core/classes/Signal.html Signal].

'''Comparable''' is a mixin module which permits the including class to implement comparison operators. The including class must define the <=> operator, which compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object. Comparable uses <=> to implement the conventional comparison operators (<, <=, ==, >=, and >) and the method between?.

'''Enumerable''' is a mix-in module for enumeration. The including class must provide the method each.

'''FileTest''' is a module containing file test functions; its methods can also be accessed from the File class.
The''' GC''' module provides an interface to Ruby’s mark and sweep garbage collection mechanism. Some of the underlying methods are also available via the ObjectSpace module.
'''Kernel''' is a module included by the Object class; it defines Ruby’s ‘built-in’ methods.

'''Math''' is a module containing module functions for basic [http://en.wikipedia.org/wiki/Trigonometric_functions trigonometric] and [http://en.wikipedia.org/wiki/Transcendental_function transcendental] functions.

'''ObjectSpace''' is a module which contains routines that interact with the [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) garbage collection] facility and allows traversing all living objects with an iterator.
'''Precision''' is a mixin for concrete numeric classes with precision

==Comparable Behavior ==
The comparable functionality is useful when there is a requirement to compare few objects and maybe even sort them.

In Ruby the comparable behavior is achieved by simply defining the <=>operator(which returns -1,0,1 depending on whether the argument object is greater than, equal to or less-than the calling object) and including the Comparable mixin.
Consider a situation where we have a class Organization and this Organization stores the information about several Organizations. Suppose we have to sort different organizations in ascending order as to which is greater by comparing only total revenue of each. The implementation in Ruby is as follows.

'''Example of Comparable in Ruby:''' 
<pre>
class Org
include Comparable
attr :name
attr :revenue
attr :emplCount
def initialize(name,revenue,emplCount)
@name = name
@revenue=revenue
@emplCount=emplCount
end
def <=>(second)
self.revenue <=> second.revenue
end
def to_s
"#{name}"
end
end
org1=Org.new('org1',100000,5000);
org2=Org.new('org2',100001,4000);
org3=Org.new('org3',100002,4000);
org4=Org.new('org4',100003,4000);
org5=Org.new('org5',100004,4000);
a=[org1,org2,org3,org4,org5];
puts a.sort
</pre>
'''output:'''
<pre>
org1
org2
org3
org4
org5

</pre>

In Java, there is an interface called [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html Comparable] which declares an abstract method called ''CompareTo''. Several pre-defined classes such as [http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Float.html Float],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Double.html Double],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Integer],[http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Long.html Long] implement this interface and provide a definition for the CompareTo method. If we have to compare two objects of our class by comparing a specific attribute of the objects, we need to implement the interface in our class and provide the implementation of the CompareTo method by writing our code in there to compare the two objects of that class.
Consider the same example as above and the implementation for java is provided below.

'''Example of Comparable in Java:''' 

<pre>
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

//import java.util.*;
public class Org implements Comparable {
String name;
Integer revenue;
int emplCount;
public Org(String name,Integer revenue, int emplCount)
{
this.name=name;
this.revenue=revenue;
this.emplCount=emplCount;

}
public int compareTo(Object obj1)
{
if (this.revenue == ((Org) obj1).revenue)
return 0;
else if ((this.revenue) > ((Org) obj1).revenue)
return 1;
else
return -1;
}
public String toString() {
return "Org " + name + "\n" ;
}
public static void main(String[] args) {
List list1 = new ArrayList();
Org org1=new Org("org1",1000000,5000);
Org org2=new Org("org2",1000001,4000);
Org org3=new Org("org3",1000002,4000);
Org org4=new Org("org4",1000003,4000);
Org org5=new Org("org5",1000004,4000);
Org org6=new Org("org6",1000005,4000);

list1.add(org1);
list1.add(org2);
list1.add(org3);
list1.add(org4);
list1.add(org5);
list1.add(org6);
Collections.sort(list1);
Iterator itr = list1.iterator();
System.out.println("The list of organizations in the ascending order of revenue are");
while(itr.hasNext()){
Object element = itr.next();
System.out.println(element + "\n");
}
}

}

</pre>
Output:
<pre>
The list of organizations in the ascending order of revenue are
Org org1

Org org2

Org org3

Org org4

Org org5

Org org6

</pre>

==Enumerable Behavior ==
'''Enumerable module'''

Various operations are supported by the Ruby Collection classes .Some of such operations are traversing the collection, sorting the collection. We can define classes that can support these features on collections by including the enumerable module and defining an iterator ‘each’. This iterator has to return the elements of the collection in turn. 
If the classes which have included the Enumerable module can implement the rocket method <=>, we can also use other methods like min, max ,sort on the collections. 
Enumerable is a standard mixin implementing operators in terms of the ‘each’ method defined the host class. The host class is that class which includes the enumerable. 
'''Usage of Enumerable'''

Ruby’s enumerable module has methods for all kinds of operations that can be performed on a collection. Collection objects which can be instances of Array,Hash etc. “mixin” the enumerable module.It gives objects of collections additional collection specific behaviors. These behaviors are given by the each method.
 

''' To Mix in Enumerable in a class,'''

<pre>
Class MyCollection
include Enumerable
#other code
def each
#definiton
end
#othercode
end
</pre>
Some of the built in classes which mixin Enumerable are : [http://ruby-doc.org/core/classes/String.html String], [http://www.ruby-doc.org/core/classes/Hash.html Hash] ,[http://www.ruby-doc.org/core/classes/Array.html Array] ,[http://www.ruby-doc.org/core/classes/Range.html Range] ,[http://www.ruby-doc.org/core/classes/Struct.html Struct].
Each class that includes ‘Enumerable’ must define the ‘each’ method as per its own requirement.

eg: the Array class ‘s each method yields each element.The Hash class‘s each yields each key-value pair as a two element array.

'''Some Useful Methods offered by Enumerable:'''
*map: modifies each member according to the instructions in a block and returns the modified collection of members.
*collect: similar to map.
*grep: The grep method ‘searches’ for members using a regular expression
eg:
<pre>
(1..10).grep (5..7) #=>[5,6,7]
</pre>
*all? : It returns true if all elements of a collection satisfy the condition in the block ie the block never returns false or nil. If no block is specified it returns true if none of the collection members are false or nil.
eg:
<pre>
%w{ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ant bear cat}.all? {|word| word.length >= 4} #=> false
</pre>

*any?
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil.
eg:<pre>
%w{ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ant bear cat}.any? {|word| word.length >= 4} #=> true
</pre>

One of the common and useful methods of enumerable is '''‘inject’'''. We can use it in any class that includes enumerable and provides the implemation for ‘each’ method. This method applies a function or operation to the first two elements in the
collection and then applies the operation to the result of this computation and to the third
element, and so on, until all elements in the collection have been used.

''' Example of using Enumerable Mixin''': In the below example, the class 'EnumerableDemo' includes the Enumerable mixin and provides the definition for 'each' which yields the digits present in a string. When inject method with the argument +,is called on the object of the class it returns a string of digits.
<pre>
class EnumerableDemo
include Enumerable
def initialize(string)
@string=string
end

def each
@string.scan(/\d/) do |num|
yield num
end
end

ed=EnumerableDemo.new("123Bond007")
puts ed.inject(:+)
</pre>
''' output:'''
<pre>
123007 #The numbers in a string are concatinated and returned.
</pre>

In Java, the Collection interface specifies some methods similar to the methods of Enumerable module. For example ''contains'' can be mapped to ''find'',''to_array'' can be mapped to ''collect''. etc. But the methods are also not as powerful as those of the Enumerable module methods. Also the implementation of these methods is not available unless we inherit from a class which implements this interface. This is unlike mixins in ruby where implementation of ‘each’ method provides us several useful collection methods for free.

'''Enumerable Interface in Java'''. 
Java provides the Enumeration Interface. But its functionality is different from the Enumerable module of ruby.In Java, the Enumeration interface defines the methods by which you can enumerate (obtain one at a time) the elements in a collection of objects.
Successive calls to the nextElement method return successive elements of the series.
''' For example, to print all elements of a vector v:'''
<pre>
for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
System.out.println(e.nextElement());

}
</pre> 
'''hasMoreElements''': Tests if this enumeration contains more elements. 
'''nextElement''': the next element of this enumeration. 

==Data Mapper==
In any software development, we often face situations where our code has to interact with a [http://en.wikipedia.org/wiki/Database database]. In such situations, we have to have knowledge of a query language like [http://en.wikipedia.org/wiki/Sql SQL] to insert into, delete from or modify a database. In modern programming languages, a feature called [http://en.wikipedia.org/wiki/Object-Relational_Mapping Object Relational Mapping] is provided. This features allow the user to access the database tuples as if they were objects. All the database operations such as insert, delete,update,etc. are implemented in the language using objects. The programmer need not have a firsthand knowledge of a query language to perform these operations.

In Ruby, Object Relational Mapping is implemented using DataMapper. The DataMapper provides wide variety of features and is [http://en.wikipedia.org/wiki/Thread_safe thread-safe](multiple [http://en.wikipedia.org/wiki/Thread_(computer_science) threads] can call it without interfering with each other.
Following are the steps involved in using the DataMapper

Step 1: Install the dm-core ruby gem – the core of the DataMapper library. This gem has no external dependencies and so, we can install it in the same way we install other gems in ruby.
''' '''

<pre>$sudo gem install dm-core</pre>

Step 2: We now need to install an adapter which allows the DataMapper to talk to the database. This is specific to each database provider.
''''''

Eg: For SQLite 3
<pre>
$ sudo apt-get install libsqlite3-dev
$ sudo gem install dm-sqlite-adapter
</pre>
'''''

Step 3: We then need to require the dm-core gem in our application.
<pre>
Require ‘rubygems’
Require’data_mapper’
Require ‘dm-core’
</pre>
Now, we have to specify the database connection to which our DataMapper must talk to. This is done using datamapper.setup

<pre>
DataMapper.setup(:default, “[dataobject]://[relative-path]”)
For SQLite, this would be something like this.
DataMapper.setup( :default, "sqlite3://#databases/myown.db" )
</pre>

Step-4 – Define models in a class using DataMapper:

The models can be created as below
<pre>
# Create and define a class Recipee
class Recipee
include DataMapper::Resource

property :Name, String: key => true
property :type, String
property :Description, text
end
</pre>
This model can be called using the DataMapper.auto_migrate command. This creates the table if it does not already exist. If the table already exists, it modifies the columns in this table. We can specify primary key by using the key=> true. The serial type is an auto increment integer key. We can create a column ID and define its type as serial to make it a key automatically.
Now, we can access these as if they were objects without having knowledge about any query language to insert and update a table.
the code
<pre>
# Create a new record
myrecipee = Recipee.new
myrecipee.attributes = {
:name => 'OrangeJuice',
:type => 'beverage',
:Description => 'Tasty!'
}

Insert: myrecipee.save to save

Modify: myrecipee.Description=’Tasty and Delicious!’
Delete: Myrecipee.destroy to deletethe tuple in the database

Select: puts myrecipee.inspect

</pre>

'''DataMapper in Java''' 
In java, [http://en.wikipedia.org/wiki/Hibernate_(Java) Hibernate], [http://en.wikipedia.org/wiki/Ibatis iBatis] are modern approaches that provide the ORM functionality. Traditionally, [http://en.wikipedia.org/wiki/Jdbc JDBC] had to be used to access the databases.The functionalities provided by Hibernate are similar to that of DataMapper in ruby- it can access the database as objects. 
Hibernate defines a language called [http://en.wikipedia.org/wiki/Hibernate_Query_Language HQL](Hybernate Query Language). HQL can be said to be the object oriented version of SQL. Java was created in 1995, but hibernate did not come into existence until 2001. Hibernate was developed by [http://en.wikipedia.org/wiki/Red_hat Redhat] in Java to introduce ORM in Java.

==Singleton Behavior==
According to Wikipedia ,''” In [http://en.wikipedia.org/wiki/Software_engineering software engineering], the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. (This concept is also sometimes generalized to restrict the instance to a specific number of objects . This is useful when exactly one object is needed to coordinate actions across the system.”'' 
The singleton design pattern is used when we desire only one instance of some class, such as one database connection, one logger instance or even one configuration object for an application.

In Ruby, the singleton behavior can be achieved by simply including the ‘Singleton’ Module.
To use ruby singleton module,
*’require’ the ‘Singleton’ and then include it in desired class.
*Use the instance method to get the instance you need.
Ruby does the following when a singleton module is included in a class.
* New method is made private so that it can’t be used for instantiation.
* A class method called ‘instance’ is added that instantiates only one instance of the class.

''' Eg'''
<pre>
class A
include Singleton
# ...
end
</pre>
this ensures that only one instance of A be created.
<pre>
a,b = A.instance, A.instance
a == b # => true
A.new # NoMethodError - new is private ...
</pre>
An instance is created at the first call of A.instance(), thus this behavior is preserved under inheritance and [http://en.wikipedia.org/wiki/Clone_(computing) cloning].This is achieved by marking A.new as private nd providing (or modifying) the class methods A.inherited() and A.clone() - to ensure that the Singletonpattern is properly inherited and cloned.

In java, the singleton design pattern proposes that at any time there can be a single instance of an object created by [http://en.wikipedia.org/wiki/Jvm JVM].
To implement this behavior, the class’s default [http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming) constructor] is made private. This prevents the direct instantiation of the object. A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object.

For implementing a singleton pattern, consider the following steps: 
Step -1: Provide a default private constructor. 
Step-2: Define a method to obtain the reference to the singleton Object. 
Step 3: The Access method has to be made synchronized to prevent Thread Problems. 
Step 4: The Object clone method has to be overridden to prevent cloning. 

''' Example of Singleton:'''
<pre>
class SingletonClass {

private static SingletonClass singletonObject;
/** A private Constructor prevents any other class from instantiating. */
private SingletonClass() {
// Optional Code
}
public static synchronized SingletonClass getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonClass();
}
return singletonObject;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

public class SingletonObjectDemo {

public static void main(String args[]) {
// SingletonClass obj = new SingletonClass();
//Compilation error not allowed
SingletonClass obj = SingletonClass.getSingletonObject();
// Your Business Logic
System.out.println("Singleton object obtained");
}
}

</pre>

==Mixin vs Interfaces==
*What makes mixins so powerful is that the methods of the host class(the class that includes the module) can be accessed in the module even before we define the host class.
''' Example:''' In the following example,we define a module 'Wisher' which defines a method 'wish' that uses a method 'name' of the host class . Next we define the host class (Person) that includes 'Wisher' and hence obtains the 'wish' method of the module.The 'Person' class contains an [http://www.rubyist.net/~slagell/ruby/accessors.html attribute reader] method 'name' and an [http://ruby.activeventure.com/usersguide/rg/objinitialization.html initialize] method. We then create an object 'p' of class 'Person' and call the method 'wish' on it.The 'wish' method uses method 'name' of Person to return a string as the output.
<pre>
module Wisher
def wish
puts "Good Day "+self.name #name ie attr_reader method of the host class is used even before the class is define.
end
end

class Person
include Wisher
def initialize(name,age)
@name=name
@age=age
end
attr_reader :name
end

p=Person.new (“James”,4)
p.wish #returns Good Day James.
</pre>
Such a feature is not supported by interfaces in java.

*'''Rewriting''' : When an interface is rewritten, all classes that implemented the older version are now broken because they no longer implement the interface. Hence the programmer has to try to anticipate all uses for the interface he/she is defining and specify it completely from the beginning. Such a problem is not caused in Ruby. Even if the module definition is changed at [http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase) run-time], the classes that include the module use the modified version of the module.

*Both Java and Ruby support single inheritance.i.e, A class can inherit features from a single class. Multiple inheritance is achieved in Java through interfaces and in Ruby through Mixins. ie A java class can extend only one class but can implement several interfaces. Hence objects can have multiple types ie the type of their own class and the type of the interfaces that their class implements. Similarly a Ruby class can be subclassed from a single class but can include many modules.(mixins). In Ruby, inheritance and mixins allow us to write code at one place and reuse it in other classes. Inheritance is used when there is an [http://en.wikipedia.org/wiki/Is_a “is-a”] relationship. Mixins are used when there is a “uses a” or [http://en.wikipedia.org/wiki/Has-a “has a”] relationship. However there is no such advantage with interfaces in java . Hence there can be misuse of inheritance as even unrelated classes can implement an interface.

*One analogy that can be used to compare interfaces in java and mixins in ruby is that interface is like a legal contract while mixin is like a promise. ie a java interface is all about meeting the rules of the extra methods that must be provided where as in ruby there are no such rules to be enforced. Consider the comparable behavior for example. Both mixins and interfaces provide similar behavior. But if a class extends' Comparable' interface and fails to implement the 'compareTo' method a compile time error occurs even if the object of the class does not attempt to use the comparable behavior. But in cases of mixins, if a class includes ‘Comparable’ mixin and does not implement the <=> method there are no errors if the object of the class does not attempt to use the comparable behavior. Hence we can think of it as a promise. If the object uses the comparable behavior ie calls methods like >,<,between? etc only then a runtime error occurs.

eg: Consider the class 'A' which includes the 'Comparable' mixin.It defines a method 'hi'. It does not implement the <=> method. When an object 'a' of class 'A' is created and method 'hi' is invoked on it, there is no exception. But there will be a exception when the methods like <,>etc are used because the <=> method has not been implemented.
<pre>
class A
include Comparable
def hi
puts "hi"
end
end

a=A.new

a.hi #returns “hi”. In java,there would be a compilation error in such a scenario since the methods of the Interface are not implemented.
</pre>

* Also classes implementing interfaces do not inherit code. ie there is no code reusability.An interface is purely something to help programs type-check in a statically typed language whereas mixins provide actual code to classes that include them. Hence mixins allow code reusability.

==Conclusion==
We have seen that some of the functionality of mixins is provided by interfaces in Java like the Comparable functionality for instance. However,we know that an interface only specifies what the class must support and cannot provide an implementation unlike a module which can be mixed into any number of classes. For [http://en.wikipedia.org/wiki/Refactor refactoring] common behavior into a single place in java (to achieve the power of mixins),we need another class which provides an implementation and is dependent on the interface.It has been observed that Interfaces when combined with [http://en.wikipedia.org/wiki/Aspect-oriented_programming aspect-oriented programming] can produce full fledged mixins in Java.

==References:==
http://ruby.about.com/od/sinatra/a/datamapper.htm . 
http://solitude.vkps.co.uk/Archives/2009/01/13/data-mappers/ 
http://javatemple.blogspot.com/2008/11/features-of-hibernate-in-nutshell.html 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html 
http://www.tutorialspoint.com/ruby/ruby_modules.htm 
http://www.javabeginner.com/learn-java/java-singleton-design-pattern 
http://www.brainbell.com/tutorials/java/Applying_Some_Structure.htm 
http://ruby-doc.org/ 
http://download.oracle.com/javase/tutorial 
http://en.wikipedia.org/wiki/Mixin 
http://en.wikipedia.org/wiki/Singleton_pattern