# 0.2 Learning objects for methods in java  (Page 4/6)

 Page 4 / 6

Exercise Write a recursive method to compute the n'th Fibonacci number:

$fib\left(0\right)=0,fib\left(1\right)=1,fib\left(n\right)=fib\left(n-1\right)+fib\left(n-2\right)\phantom{\rule{0.277778em}{0ex}}\phantom{\rule{0.277778em}{0ex}}\mathit{for}\phantom{\rule{0.277778em}{0ex}}\phantom{\rule{0.277778em}{0ex}}n>1.$

Exercise Write a more efficient nonrecursive method for the same function.

## Calling methods on an object

Concept Nonstatic methods defined in a class must be invoked on an object of the class. A reference to the object becomes an implicit actual parameter that initializes a formal variable called this in the method. The variable this need not be explicitly mentioned when accessing fields of the object unless there is an ambiguity.

Program: Method05.java

// Learning Object Method05 //    calling methods on an objectclass Song {     int seconds;      Song(int s) {        seconds = s;     }      double computePrice(double pricePerSecond) {       return seconds * pricePerSecond;     }}  public class Method05 {     public static void main(/*String[] args*/) {         Song song1 = new Song(164);        Song song2 = new Song(103);         double price1 = song1.computePrice(0.01);        double price2 = song2.computePrice(0.02);         System.out.println(price1);        System.out.println(price2);     }}

This program computes the cost of a song as the product of its length in seconds and the price per second. A class Song is defined to encapsulate the field seconds and the method computePrice .

• Two objects of class Song are instantiated and references to them are assigned to the variables song1 and song2 .
• The method computePrice is called on the object referenced by song1 . In Jeliot this is visualized by an arrow to the object placed in the Expression Evaluation Area followed by a period and the method name and parameters.
• An activation record is allocated containing two formal parameters: this is initialized by the implicit reference and pricePerSecond is initialized from the actual parameter.
• The reference in the parameter this is used to obtain the value of the field seconds . An expression is evaluated and its value returned.
• The activation record is deallocated and the value returned is stored in the variable price1 .
• A second call to the method is executed in exactly the same way, except that it is called on the object referenced by song2 .
• The values of price1 and price2 are printed.

Exercise Modify the method so that the formal parameter is also named seconds . Yes, it can be done! (Hint: read the Concept paragraph above.)

## Calling a method on the same object

Concept A nonstatic method defined in a class that is invoked on an object of the class can invoke another such method on the same object. The object for the second call is the same as the one on the first call,namely, the only referenced by this . There is no need to explicitly write this and the object may be accessed implicitly.

Program: Method06A.java

// Learning Object Method06A //    calling a method on the same objectclass Song {     int seconds;      Song(int s) {        seconds = s;     }      boolean discount(int s) {        return s > 300;     }      double computePrice(double pricePerSecond) {        double price = seconds * pricePerSecond;         if (discount(seconds))            price = price * 0.9;         return price;    } }  public class Method06A {    public static void main(/*String[] args*/) {        Song song1 = new Song(164);         Song song2 = new Song(403);        double price1 = song1.computePrice(0.01);         double price2 = song2.computePrice(0.01);        System.out.println(price1);         System.out.println(price2);    } }