CSC/ECE 517 Fall 2012/ch1 1w22 an

From Expertiza_Wiki
Revision as of 03:36, 9 September 2012 by Asheikh (talk | contribs)
Jump to navigation Jump to search

Introduction

When we define a method in a class and decide to call that method, how do we do it?

We simply create an object of the class and pass the method name to the object as a message. The object then looks up into its method lookup path and tries to match the called method (passed as a message to the object) with the defined methods in the class. When there is a match, the method is executed along with the parameters passed and the result is returned.

What is a Method Lookup Path?

When the object receives a method name that is to be executed, these are the steps carried out for finding out that method called:

  • It looks in the current self object’s own instance methods.
  • Then it looks in the list of instance methods that all objects of that class share.
  • Then in each of the included modules of that class, in reverse order of inclusion.
  • Then it looks in that class’s superclass.
  • Then in the superclass’s included modules, all the way up until it reaches the class Object.
  • If it still can’t find a method, the very last place it looks is in the Kernel module, included in the class Object.
  • Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

What is method_missing?

Now suppose that the object does not find a matching method in its method lookup path i.e there is no such method defined in the class. Then what?

The NoMethodError Exception is raised .

Examples

A Simple Illustration

class A			// creating a class A
def say			// defining a method say
puts " say Hi "
end
end

Now, creating the object of the class

 a=A.new	         // object of the class
 => #<A:0x2a082e0>      //object id

Calling the defined method

a.say                  // defined method
=> say Hi		       // returned result

Calling the undefinedd method

a.sayhi                  // undefined method
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0>   // the NoMethodError is raised

Here is where the method_missing comes into picture. The name “method_missing” should be self explanatory that it is invoked when a method is not found. It is a method of last resort. This method accepts the name of the non-existing method, the array of arguments passed and also any associated block to the method.

The format for defining method_missing

=> def method_missing(m,*args,&block)

method_missing implementation

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block)		// defining method_missing
puts " This method does not exist"		// body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi
=> This method does not exist		// this result returned when method_missing is executed

>> Explanation: When the object 'a' traces its method lookup path for a matching method as 'sayhi', after a failure it resorts to method_missing and the body of method_missing is executed.

NoteThere is something interesting that programmers do. Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods will the user call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class ; or it just does what needs to be done, this is in the hands of the programmer.


Now, let us look into a few more examples to get the concept right.