1.9 Method Signatures

1. Methods and procedural abstraction

A method is a named block of code that only runs when it is called. A block is any section of code enclosed in braces { } 1.9.A.1.

Procedural abstraction allows a programmer to use a method by knowing what the method does, even without knowing how it was written 1.9.A.1. You call Math.sqrt(16.0) without ever seeing its code.

2. Parameters and method signatures

A parameter is a variable declared in the header of a method or constructor. It can be used inside the body of the method, and it lets values (arguments) be passed in and used by the method 1.9.A.2.

A method signature for a method with parameters is the method name plus the ordered list of parameter types. For a method without parameters, the signature is the method name plus an empty parameter list, for example getHeight() 1.9.A.2.

Reading a method header, part by part:

// not runnable: a method header from the Java Quick Reference
public static double pow(double base, double exponent)

Part of the header	Meaning
static	a class method (topic 1.10)
double (before pow)	the return type: the type of value sent back
pow	the method name
(double base, double exponent)	the parameter list: the type and name of each parameter
pow(double, double)	the signature: name + ordered parameter types

Same name, different signatures means overloaded methods (section 5).

3. Calling void and non-void methods

A void method does not have a return value, so it is not called as part of an expression 1.9.B.1. p.grow(5); is fine as a statement on its own.

// does not compile
Plant p = new Plant("Fern", 30);
int h = p.grow(5);

Real view:

error: incompatible types: void cannot be converted to int

A non-void method returns a value of the same type as the return type in its header. To use the returned value, store it in a variable or use it as part of an expression 1.9.B.2.

Plant p = new Plant("Fern", 30);
p.grow(5);                   // void: a statement on its own
int h = p.getHeight();       // non-void: value stored
System.out.println(h);
System.out.println(p.getHeight() * 2);   // value used in an expression

Output:

35
70

4. Arguments and call by value

An argument is a value passed into a method when the method is called. Arguments must be compatible in number and order with the types in the parameter list of the method signature. An int argument can go to a double parameter, as in Math.pow(2, 10), because the int is widened (topic 1.5). Arguments are passed using call by value: each parameter is initialized with a copy of the argument 1.9.B.3. Changing the parameter inside the method does not change the caller’s variable.

public static void addTen(int value)
{
    value = value + 10;
    System.out.println("Inside: " + value);
}

// in main
int score = 5;
addTen(score);
System.out.println("Outside: " + score);

Output:

Inside: 15
Outside: 5

value gets a copy of 5 and becomes 15, but score in main is still 5. The copy disappears when the method ends.

5. Overloaded methods

Methods are overloaded when there are several methods with the same name but different signatures 1.9.B.4, for example abs(int x) and abs(double x). Java picks the method whose parameter types match the arguments, in order.

public static void show(int points)
{
    System.out.println("Points: " + points);
}

public static void show(String player, int points)
{
    System.out.println(player + ": " + points);
}

public static void show(int points, String player)
{
    System.out.println(points + " for " + player);
}

// in main
show(12);
show("Ana", 12);
show(12, "Ana");

Output:

Points: 12
Ana: 12
12 for Ana

Two methods with the same name and the same parameter types do not compile, even if the parameter names differ:

// does not compile
public static int area(int side) { return side * side; }
public static int area(int length) { return length * length; }

// in main
System.out.println(area(3));

Real view:

error: method area(int) is already defined in class Main

Background (not tested): exact matches win. When one overload matches the argument types exactly, Java uses it, so Math.abs(-4) uses abs(int) and returns the int 4, while Math.abs(-4.0) uses abs(double) and returns 4.0.

System.out.println(Math.abs(-4));
System.out.println(Math.abs(-4.0));

Output:

4
4.0

6. Flow of control in a method call

A method call interrupts the sequential execution of statements. The program first runs the statements in the method. Once the last statement in the method has run, or a return statement runs, the flow of control returns to the point right after the call 1.9.B.5.

public static void greet()
{
    System.out.println("  inside greet");
}

// in main
System.out.println("before");
greet();
System.out.println("after");

Output:

before
  inside greet
after

Arguments are worked out before the call, so nested calls run inside out. In Math.sqrt(Math.abs(-16)), Math.abs(-16) runs first and gives 16, then Math.sqrt(16) gives 4.0.

System.out.println(Math.sqrt(Math.abs(-16)));

Output:

4.0