المعاملات والقيم المُرجَعة

Written Explanation

Parameters in, a value out

Here is a method with two parameters and a return value:

static int add(int a, int b) {
    return a + b;
}

The Oracle tutorial defines the signature of a method as its name plus its parameter types; for add that is add(int, int). Lesson 3 uses that idea heavily.

In the recipe-card picture: the parameters are the ingredient list at the top of the card, the return type is the dish the card produces, and return is the moment the finished dish is handed over.

Parameters versus arguments

Two words that beginners mix up:

• A parameter is the variable in the method declaration: a and b above. It is a placeholder.
• An argument is the actual value you supply in a call: in add(3, 4), the arguments are 3 and 4.

When you call a method, Java evaluates each argument and copies its value into the matching parameter, in order: first argument to the first parameter, second to the second. The names do not have to match; the position does. Lesson 4 explains what "copy" implies.

Using the returned value

A call to a method that returns a value is an expression: it has a value, so it can go anywhere a value can.

int total = add(3, 4);                       // store it
System.out.println(add(10, 20) + add(1, 1)); // use it in an expression
if (add(2, 2) == 4) { ... }                  // test it

If you write add(3, 4); as a statement alone, Java accepts it but throws the result away, which is rarely what you wanted.

return ends the method

return does two things: it supplies the value and it leaves the method immediately. Any statement after a return on the same path never runs (the compiler rejects unreachable code). This allows several return statements, one per decision:

static double discountRate(double subtotal) {
    if (subtotal >= 100) {
        return 0.10;
    }
    if (subtotal >= 50) {
        return 0.05;
    }
    return 0.0;
}

Because each return leaves at once, no else is needed. Remember the rule from Module 12: order the tests from the most demanding to the least.

Every path must return. If a method has a non-void return type, the compiler insists that it cannot reach the closing brace without returning a value. A version of the method above that had only the first if would not compile:

Err2.java:6: error: missing return statement
    }
    ^

void: nothing comes back

A void method returns no value. It may still use a bare return; to stop early, but cannot return a value. Because there is nothing to hold, you cannot assign its result:

Err1.java:9: error: incompatible types: void cannot be converted to int
        int x = hello();
                     ^

Use void for methods whose job is an action, such as printing a menu. Use a real return type whenever the caller will want the answer.

Type checks at the call

Java checks every call against the declaration, at compile time:

• The number of arguments must equal the number of parameters.
• Each argument must be convertible to the parameter type. An int can be passed where a double is expected (a widening conversion from Module 9), but a double cannot be passed where an int is expected without a cast, because data could be lost.
• The returned value must fit the declared return type.

Here are the two real compiler messages for those mistakes, calling add(int a, int b):

error: incompatible types: possible lossy conversion from double to int
        int y = add(1, 2.5);
                       ^
error: method add in class Err1 cannot be applied to given types;
  required: int,int
  found:    int
  reason: actual and formal argument lists differ in length

Compute or print, not both

Compare two versions of the same job:

static void addAndPrint(int a, int b) {     // locked to printing
    System.out.println(a + b);
}

static int add(int a, int b) {              // reusable
    return a + b;
}

With add, the caller decides what to do: print it, store it, add it to a running total, compare it, or format it with two decimals. With addAndPrint, the number goes to the screen and is gone. A method that returns a value can also be tested by checking the value, which you will do in the testing module; testing something that only prints is much harder.

The rule: methods that do the work return a result; methods that show results print. Keep them separate and combine them in the caller, e.g. printArea(w, h) calls area(w, h).