More on Methods

More About Java Methods

Method Overloading

Method Overloading means that it is legal to have more than one method with the same name (in the same class), as long as they have different parameter lists. The difference can be in number of parameters or in the types of parameters.

Example:

   int Process(double num);		  // method 1
   int Process(char letter);              // method 2
   int Process(double num, int position); // method 3

Notice that although all three methods have the same exact name, they each have a different parameter list. The compiler can then distinguish the calls:

   x = Process(3.45, 12);	// invokes the third function above
   x = Process('f');		// invokes the second function

Ambiguous Invocation

Because of function overloading and the legality of some automatic type conversions, it is possible to make a call that could match two methods (due to the type conversion issue). This will result in a compiler error. Example:

  double Sum(int x, double y);
  double Sum(double x, int y);

This pair of methods is legal, since the parameter lists differ. But the following is an illegal call, due to ambiguous invocation:

  System.out.print("The sum is " + Sum(3, 4));

The Math Class

For certain kinds of mathematical calculations, there are many methods available in a pre-built class called Math

Trigonmetry methods
- sin, cos, tan, asin, acos, atan
Exponent methods
- exp - raise e to a power
- log - natural log of a number (base e)
- pow - raise one number to a power
- sqrt - square root
Rounding methods
- ceil - round up to nearest integer
- floor - round down to nearest integer
- rint, round (2 versions) - rounding methods
Miscellaneous methods

min - find minimum of two numbers
max - find maximum of two numbers
abs - find absolute value of a number
random - returns a random number in range [0.0,1.0)

The Math class API

Recursive Methods

A recursive method is a function that calls itself.

Many tasks can be done with recursion or with iteration. When using recursive functions, one should take care to make sure that there is a "way out". At some point, the function must stop calling itself and be allowed to exit -- and each instance of the function will return to the previous instance (often returning a value).

A typical example: Factorials

n! is defined as n * (n-1) * (n-2) * ... * 1. We can define a factorial function (iteratively) as follows:

   static long Factorial(int n)
   {
      unsigned long f = 1;
      for (int i = n; i >= 1; i--)
         f *= i;

      return f;		// this is the answer
   }

But notice also that:

  n! = n * (n-1)!

By using this formula, we can define a factorial function recursively:

   static long Factorial(int n)
   {
	if (n <= 1)	// base case
	   return 1;
	else
	   return (n * Factorial(n-1));
   }