The following method takes 2 arguments:

static double hypotSquared(double leg0, double leg1) { return leg0*leg0 + leg1*leg1; }

Recall that in any arithmetic expression, multiplication takes precedence over addition, so the method really does return the square of the hypotenuse .

The MethodLab animated illustration demonstrates the passing of arguments and the returning of return values. To run the program, type java methods.MethodLab . The display presents code that calls a method, as shown in Figure 4.1.

Figure 4.1: MethodLab

Click on the Run button to see the animation. The black lines indicate the passing of arguments, which are called a and b in the caller but x and y in the method. The blue line represents returning the return value. When the animation is finished, click Reset to start again. Figure 4.2 shows MethodLab after the animation finishes.

Figure 4.2: MethodLab after animating

You can customize MethodLab by typing any integer value you like into the text fields for a and b . You can also enter any numeric formula for the value of z , which becomes the return value. Try the formula in the preceding example. Since this method's arguments are called x and y , the formula should be

x*x + y*y

With this formula, try running MethodLab with a = 3 and b = 4. Try again with a = 12 and b = 5. These combinations are the only small integers that represent triangles with integer hypotenuses.

A method's argument list can be arbitrarily long. At times you might even want a method with no arguments at all. In that case, the method's declaration has an empty pair of parentheses after the name, and the caller passes nothing at all inside its own parentheses:

float f = sayHello(); … static float sayHello() { System.out.println("Hello"); return 3.14159f; }

The important thing is that when you call a method, the call should have the same number of arguments as the method declaration, and the types of the arguments passed by the caller should be compatible with the types in the method declaration. This is subtly different from saying that the caller's argument types should exactly match the types in the method declaration. Recall from Chapter 3 that a value can be assigned to a variable of a different type, provided the new type is wider than the old type. Figure 4.3 (first shown in Chapter 3) shows the width relationships among the numeric primitive types.

Figure 4.3: Numeric type widths

The rule for passing method arguments is similar to the rule for assignment: You can pass an argument whose type is different from the type declared by the method, provided the type declared by the method is wider than the type that you pass . Recall that a type is wider than another type if you can get from the first type to the second type by following the arrows in Figure 4.3.

For example, suppose a method has the following declaration:

static char abcde(long wayToGo)

This method can be called with a long argument, or with any argument whose type is narrower than long: byte, short, char, or int.

More on Return Types

At times, you might want to create a method that doesn't return anything. The method might print out a message, display a dialog box, or store a value in a file. In cases such as these, it is difficult to think of any value that the method could meaningfully return, and concocting a return value just for the sake of having one would not contribute to the quality of the program. (A basic principle of writing fiction is that every word should contribute to developing the plot or developing the characters. We can invent a similar principle for writing software: Every word of source code should contribute to the operation or the readability of the program.)

Suppose you want a method that prints a number along with a message. Since no return value is needed or relevant, replace the return type in the declaration with the word void :

static void printPretty(int x) { System.out.println("x = " + x); }

Note the absence of a return statement. A void method runs until it executes its last line. Then it returns automatically. Optionally, you can add a return statement with no value at the end of the method:

static void printPretty(int x) { System.out.println("x = " + x); return; }

Here the return statement doesn't contribute to program execution or readability (we already know that the method returns when it hits bottom), but later we will see cases where explicitly saying return can be useful.

A call to a method with a non-void return type can be used anywhere that a variable or literal of the same type can be used: as the right-hand side of an assignment, as an operand in an operation, or even as an argument of another method call. By contrast, a call to a void method has no type. So if method iAmVoid is void, you could not say int z = iAmVoid(); because there would be no value to assign to z . When you call a void method, you just want it to do its thing, so you make the call all by itself, followed by a semicolon, like this:

iAmVoid();

If a method changes the state of the program or the computer in any way (other than returning the return value), the change is called a side effect . Clearly, when you call a void method, you do so because you are interested in a side effect. (In this example, the side effect was the printing of the message.) Sometimes you might want to call a non-void method, not because you are interested in the return value, but because you want the side effect. In that case, you can just call the method as if it were void.

For example, the following method both prints out and returns hypotenuse squared:

static int vocalHypotSquared(int a, int b) { int hSquared = a*a + b*b; System.out.println("h-squared = " + hSquared); return hSquared; }

If you just wanted to print out the message, you could call the method like this, ignoring the return value:

vocalHypotSquared(5, 12);

Polymorphism

Polymorphism comes from the Greek for "many forms." It is one of several five-syllable words pertaining to object-oriented programming. In our context, it means that a method can have one name but many forms. In other words, you can define multiple methods with the same name.

At first, this might seem impossible . How can the system know which of the various methods you had in mind? The rule is that if two methods have the same name, their argument lists have to be different. That is, the types that appear in lists must differ ; the argument names are not considered here. If a method name appears more than once, we say that the name is overloaded.

For example, the following two methods could appear in the same program:

static int getMass(int n) { … } static int getMass(double a, char c) { … }

Here, getMass() is legitimately overloaded. However, the following two methods could not appear in the same program:

static int getMass(int n) { … } static int getMass(int x) { … }

The argument names are different, but that doesn't help. Both method versions have the same name, and each version takes a single argument of type int, so the compilation will fail. If the argument types were different (for example, if the argument of getMass() had type long or byte), the code would compile without error.

Methods That Call Methods

Methods can be called from anywhere – even from other methods. In fact, any complicated program is likely to consist of methods that call other methods that call other methods, and so on, to many levels of depth. For example, you might have a method that prints out two values:

static void print2Vals(int val0, int val1) { System.out.println(val0 + " and " + val1); }

Now what if you want a method that prints out the cubes of its two arguments? You might do it as follows:

static void print2Cubes(int val0, int val1) { int val0Cubed = val0*val0*val0; int val1Cubed = val1*val1*val1; System.out.println(val0Cubed + " and " + val1Cubed); }

Since you already have the print2Vals method, you can rewrite print2Cubes as follows:

static void print2Cubes(int val0, int val1) { int val0Cubed = val0*val0*val0; int val1Cubed = val1*val1*val1; print2Vals(val0Cubed, val1Cubed); }

Now you have a method, ( print2Cubes ) that calls another method ( print2Vals ). You can rewrite print2Cubes to be even more terse, as follows:

static void print2Cubes(int val0, int val1) { print2Vals(val0*val0*val0, val1*val1*val1); }

Since the multiplication is repetitious, you can also introduce a new method:

static int nCubed(int n) { return n*n*n; }

Now print2Cubes becomes

static void print2Cubes(int val0, int val1) { print2Vals(nCubed(val0), nCubed(val1)); }

Now you have a method, ( print2Cubes ) that consists of a single call to another method ( print2Vals ), and that call's arguments are both expressed as method calls (to nCubed ). This kind of structure—calls to calls to calls—is perfectly typical of programs.

Passing by Value

In formal computer terminology, we say that Java passes by value . This is just another way to say that methods get copies of their arguments and have no access to the original values. The alternative is called passing by reference , where methods work with the caller's data and not with copies. The latter is a perfectly valid way to design a language; it's just not the way Java does it.

When a caller calls a method and the flow detours into the method's body, the JVM copies the argument values provided by the caller and gives the copies to the method. This means that if the method alters its arguments, the alteration has no effect on the caller.

Consider the following method:

static void print3x(int x) { x = 3*x; System.out.println("3 times x = " + x); }

The method triples its argument. You might wonder what happens to the value that the caller passes to the method. For example, what does the following print out?

int z = 10; print3x(z); System.out.println("Now z is " + z);

Does this code print "Now z is 10" or "Now z is 30"? If the method has access to the actual data passed in by the caller, the code should print out "Now z is 30". However, the code actually prints "Now z is 10" because the method triples its own private copy, not touching the

caller's version. After the method returns, the memory used for storing the method's copy is recycled. The method's copy does not survive after the method returns.