Method Definitions

• Let's define a method for computing factorials, and use it in an applet for estimating exp(x), that is, the natural logarithm, e, raised to the xth power.
• Let x**y represent x raised to the yth power.
• A formula for e**x is as follows:

  e**x = x**0 / 0! + x**1 / 1! + x**2 / 2! + x**3 / 3! + ...

• A good estimate for this infinite sum is the 1st 10 terms.
• Clearly, it would be useful to have a method

  public long fact(int n)

  that takes an integer n, and returns a long integer whose value is n!.

• The fact method receives a copy of the value of i from the statement where fact is invoked.
• Changing the value of i in the fact method does not change the value of i in the paint method.
• The keyword long preceding the name of the method, fact, indicates that the type of the value returned by fact is a long (integer).
• The return statement returns the value, and exits the fact method at that point.
• If the type of return value of a method is specified as void, then nothing is returned.
• In this case, we use a return statement with no expression after it ( return; ).
• When we specify a method's parameters, we must include their type.
• The type of each parameter must be given individually.
• Between the braces, { }, is the method body, consisting of declarations and statements.
• It is a syntax error to define a method within the body of another method.
• A method typically is no longer than 1 page (60 lines).
• The method header (that part that appears before the opening brace) should fit on 1 line.
• Lots of parameters may be a sign of a method that lacks a single, well-defined purpose.
• If the method has no return value (void), then it can return control to the point of invocation by:
  • executing the last statement before the method-ending right brace, }
  • executing a return;
• If the method does have a return value, then control is passed back to the point of invocation by executing the statement return expression;, returning the value of the expression.

  Coercion of Arguments

•   Our fact method, which takes an int argument, can be passed a byte, char, or short variable;

the compiler automatically creates a temporary int of equivalent value and passes this to the fact method.

• However, if we passed fact a double, we would get a compiler error unless we cast it:

  double x = 2.0;
  i = fact( (int) x ); //would not get a compiler error

  Promotion rules

• When an arithmetic expression contains a mixture of types, operands get promoted so that they all match in type without losing information.

  That is, the compiler creates temporary variables of equivalent value all of the same type.

  byte -> short -> int -> long -> float -> double

  char -> int -> long -> float -> double

• For example,

  char c = 'a';
  int i = 2;
  float f = 3.0;

  f += c - i; // c and i are promoted to float