> ### Section 4.4
> Return Values

> A SUBROUTINE THAT RETURNS A VALUE is called a function. A given function can only a return value of a specified type, called the return type of the function. A function call generally occurs in a position where the computer is expecting to find a value, such as the right side of an assignment statement, as an actual parameter in a subroutine call, or in the middle of some larger expression. A boolean-valued function can even be used as the test condition in an `if`, `while`, or `do..while` statement.

> (It is also legal to use a function call as a stand-alone statement, just as if it were a regular subroutine. In this case, the computer ignores the value computed by the subroutine. Sometimes this makes sense. For example, the function `TextIO.getln()`, with a return type of `String`, reads and returns a line of input typed in by the user. Usually, the line that is returned is assigned to a variable to be used later in the program, as in the statement "`name = TextIO.getln();`". However, this function is also useful as a subroutine call statement "`TextIO.getln();`", which still reads all input up to and including the next carriage return. Since this input is not assigned to a variable or used in an expression, it is simply discarded. Sometimes, discarding unwanted input is exactly what you need to do.)

> You've already seen how functions such as `Math.sqrt()` and `TextIO.getInt()` can be used. What you haven't seen is how to write functions of your own. A function takes the same form as a regular subroutine, except that you have to specify the value that is to be returned by the subroutine. This is done with a return statement, which takes the form:

> return expression;

> Such a `return` statement can only occur inside the definition of a function, and the type of the expression must match the return type that was specified for the function. (More exactly, it must be legal to assign the expression to a variable whose type is specified by the return type.) When the computer executes this `return` statement, it evaluates the expression, terminates execution of the function, and uses the value of the expression as the returned value of the function.

> For example, consider the function definition

>              static double pythagorus(double x, double y) {
>                    // Computes the length of the hypotenuse of a right
>                    // triangle, where the sides of the triangle are x and y.
>                  return  Math.sqrt(x*x + y*y);
>              }

> Suppose the computer executes the statement "`totalLength = 17 + pythagorus(12,5);`". When it gets to the term `pythagorus(12,5)`, it assigns the actual parameters `12` and `5` to the formal parameters `x` and `y` in the function. In the body of the function, it evaluates `Math.sqrt(12.0*12.0 + 5.0*5.0)`, which works out to `13.0`. This value is returned, so it replaces the function call in the statement "`totalLength = 17 + pythagorus(12,5);`". The return value is added to `17`, and the result, 30.0, is stored in the variable, `totalLength`. The effect is the same as if the statement had been "`totalLength = 17 + 13.0;`".

> (Inside an ordinary subroutine -- with declared return type "`void`" -- you can use a `return` statement with no expression to immediately terminate execution of the subroutine and return control back to the point in the program from which the subroutine was called. This can be convenient if you want to terminate execution somewhere in the middle of the subroutine, but `return` statements are fairly rare in non-function subroutines. In a function, on the other hand, a return statement, with expression, is always required.)

> Here is a very simple function that could be used in a program to compute 3N+1 sequences. (The 3N+1 sequence problem is one we've looked at several times already.) Given one term in a 3N+1 sequence, this function computes the next term of the sequence:

>             static int nextN(int currentN) {
>                if (currentN % 2 == 1)     // test if current N is odd
>                   return 3*currentN + 1;  // if so, return this value
>                else
>                   return currentN / 2;    // if not, return this instead
>             }

> Exactly one of the two `return` statements is executed to give the value of the function. A `return` statement can occur anywhere in a function. Some people, however, prefer to use a single `return` statement at the very end of the function. This allows the reader to find the `return` statement easily. You might choose to write `nextN()` like this, for example:

>             static int nextN(int currentN) {
>                int answer;  // answer will be the value returned
>                if (currentN % 2 == 1)    // test if current N is odd
>                   answer = 3*currentN+1; // if so, this is the answer
>                else
>                   answer = currentN / 2; // if not, this is the answer
>                return answer;   // (Don't forget to return the answer!)
>             }

> Here is a subroutine that uses this `nextN` function. In this case, the improvement from the version in Section 3 is not great, but if `nextN()` were a long function that performed a complex computation, then it would make a lot of sense to hide that complexity inside a function:

>              static void Print3NSequence(int startingValue) {

>                    // Prints a 3N+1 sequence to standard output, using
>                    // startingValue as the initial value of N.  It also
>                    // prints the number of terms in the sequence.
>                    // The value of startingValue must be a positive integer.

>                 int N;       // One of the terms in the sequence.
>                 int count;   // The number of terms found.

>                 N = startingValue;   // Start the sequence with startingValue;
>                 count = 1;

>                 TextIO.putln("The 3N+1 sequence starting from " + N);
>                 TextIO.putln();
>                 TextIO.putln(N);  // print initial term of sequence

>                 while (N > 1) {
>                     N = nextN( N );   // Compute next term,
>                                       //            using the function nextN.
>                     count++;          // Count this term.
>                     TextIO.putln(N);  // Print this term.
>                 }

>                 TextIO.putln();
>                 TextIO.putln("There were " + count + " terms in the sequence.");

>              }  // end of Print3NSequence()

> Here are a few more examples of functions. The first one computes a letter grade corresponding to a given numerical grade, on a typical grading scale:

>            static char letterGrade(int numGrade) {

>                  // Returns the letter grade corresponding to
>                  // the numerical grade, numGrade.

>               if (numGrade >= 90)
>                  return 'A';   // 90 or above gets an A
>               else if (numGrade >= 80)
>                  return 'B';   // 80 to 89 gets a B
>               else if (numGrade >= 65)
>                  return 'C';   // 65 to 79 gets a C
>               else if (numGrade >= 50)
>                  return 'D';   // 50 to 64 gets a D
>               else
>                  return 'F';   // anything else gets an F

>            }  // end of function letterGrade()

> The type of the return value of `letterGrade()` is `char`. Functions can return values of any type at all. Here's a function whose return value is of type `boolean`. It demonstrates some interesting programming points, so you should read the comments:

>            static boolean isPrime(int N) {

>                  // Returns true if N is a prime number.  A prime number
>                  // is an integer greater than 1 that is not divisible
>                  // by any positive integer, except itself and 1.  If N has
>                  // any divisor, D, in the range 1 < D < N, then it
>                  // has a divisor in the range 2 to Math.sqrt(N), namely
>                  // either D itself or N/D.  So we only test possible
>                  // divisors from 2 to Math.sqrt(N).

>               int divisor;  // A number we will testing to see whether it
>                             //    evenly divides N.

>               if (N <= 1)
>                  return false;  // No number <= 1 is a prime.

>               int maxToTry = (int)Math.sqrt(N);
>                    // We will try to divide N by numbers between
>                    // 2 and maxToTry; If N is not evenly divisible
>                    // by any of these numbers, then N is prime.
>                    // (Note that since Math.sqrt(N) is defined to
>                    // return a value of type double, the value
>                    // must be typecast to type int before it can
>                    // be assigned to maxToTry.)

>                for (divisor = 2; divisor <= maxToTry; divisor++) {
>                    if ( N % divisor == 0 )  // Test if divisor evenly divides N.
>                       return false;         // If so, we know N is not prime.
>                                             // No need to continue testing.
>                }

>                // If we get to this point, N must be prime.  Otherwise,
>                // the function would already have been terminated by
>                // a return statement in the previous for loop.

>                return true;  // Yes, N is prime.

>             }  // end of function isPrime()

> Finally, here is a function with return type `String`. This function has a `String` as parameter. The returned value is a reversed copy of the parameter. For example, the reverse of "Hello World" is "dlroW olleH". The algorithm for computing the reverse of a string, `str`, is to start with an empty string and then to append each character from `str`, starting from the last character of `str` and working backwards to the first.

>                static String reverse(String str) {
>                      // Returns a reversed copy of str.
>                   String copy;  // The reversed copy.
>                   int i;        // One of the positions in str,
>                                 //       from str.length() - 1 down to 0.
>                   copy = "";    // Start with an empty string.
>                   for ( i = str.length() - 1;  i >= 0;  i-- ) {
>                            // Append i-th char of str to copy.
>                      copy = copy + str.charAt(i);
>                   }
>                   return copy;
>                }

> A palindrome is a string that reads the same backwards and forwards, such as "radar". The `reverse()` function could be used to check whether a string, `word`, is a palindrome by testing "`if (word.equals(reverse(word))`".

> By the way, a typical beginner's error in writing functions is to print out the answer, instead of returning it. This represents a fundamental misunderstanding. The task of a function is to compute a value and return it to the point in the program where the function was called. That's where the value is used. Maybe it will be printed out. Maybe it will be assigned to a variable. Maybe it will be used in an expression. But it's not for the function to decide.

> I'll finish this section with a complete new version of the 3N+1 program. This will give me a chance to show the function `nextN()`, which was defined above, used in a complete program. I'll also take the opportunity to improve the program by getting it to print the terms of the sequence in columns, with five terms on each line. This will make the output more presentable. This idea is this: Keep track of how many terms have been printed on the current line; when that number gets up to 5, start a new line of output. To make the terms line up into columns, I will use the version of `TextIO.put()` with signature put(int,int). The second `int` parameter tells how wide the columns should be.

>           public class ThreeN2 {

>              /*
>                  A program that computes and displays several 3N+1
>                  sequences.  Starting values for the sequences are
>                  input by the user.  Terms in a sequence are printed
>                  in columns, with five terms on each line of output.
>                  After a sequence has been displayed, the number of
>                  terms in that sequence is reported to the user.
>              */

>              public static void main(String[] args) {

>                 TextIO.putln("This program will print out 3N+1 sequences");
>                 TextIO.putln("for starting values that you specify.");
>                 TextIO.putln();

>                 int K;   // Starting point for sequence, specified by the user.
>                 do {
>                    TextIO.putln("Enter a starting value;");
>                    TextIO.put("To end the program, enter 0: ");
>                    K = TextIO.getInt();   // get starting value from user
>                    if (K > 0)          // print sequence, but only if K is > 0
>                       Print3NSequence(K);
>                 } while (K > 0);       // continue only if K > 0

>              } // end main()

>              static void Print3NSequence(int startingValue) {

>                    // Prints a 3N+1 sequence to standard output, using
>                    // startingValue as the initial value of N.  Terms are
>                    // printed five to a line.  The subroutine also
>                    // prints the number of terms in the sequence.
>                    // The value of startingValue must be a positive integer.

>                 int N;       // One of the terms in the sequence.
>                 int count;   // The number of terms found.
>                 int onLine;  // The number of terms that have been output
>                              //     so far on the current line.

>                 N = startingValue;   // Start the sequence with startingValue;
>                 count = 1;           // We have one term so far.

>                 TextIO.putln("The 3N+1 sequence starting from " + N);
>                 TextIO.putln();
>                 TextIO.put(N, 8);  // Print initial term, using 8 characters.
>                 onLine = 1;        // There's now 1 term on current output line.

>                 while (N > 1) {
>                     N = nextN(N);  // compute next term
>                     count++;   // count this term
>                     if (onLine == 5) {  // If current output line is full
>                        TextIO.putln();  // ...then output a carriage return
>                        onLine = 0;      // ...and note that there are no terms
>                                         //               on the new line.
>                     }
>                     TextIO.put(N, 8);  // Print this term in an 8-char column.
>                     onLine++;   // Add 1 to the number of terms on this line.
>                 }

>                 TextIO.putln();  // end current line of output
>                 TextIO.putln();  // and then add a blank line
>                 TextIO.putln("There were " + count + " terms in the sequence.");

>              }  // end of Print3NSequence()

>              static int nextN(int currentN) {
>                     // Computes and returns the next term in a 3N+1 sequence,
>                     // given that the current term is currentN.
>                  if (currentN % 2 == 1)
>                     return 3 * currentN + 1;
>                  else
>                     return currentN / 2;
>              }  // end of nextN()

>           } // end of class ThreeN2

> You should read this program carefully and try to understand how it works. Here is an applet version for you to try:

> Sorry, your browser doesn't
> support Java.

[ Next Section | Previous Section | Chapter Index | Main Index ]