Methods and the Java API Library

Why methods

A method is a named, reusable block of code. Methods eliminate duplication, give a name to an idea, and let a large problem be solved one small piece at a time (top-down design, Chapter 2). A helper method is a method that exists only to serve other methods of the same class; it is usually private.

Anatomy of a method

public static double average(int a, int b) {   // modifiers, return type, name, parameter list
    double result = (a + b) / 2.0;             // local variable
    return result;                             // return statement
}
// called as:  double avg = average(7, 10);     <- 7 and 10 are the ARGUMENTS

• The return type says what kind of value comes back; void means nothing does. A void method may still contain return; to exit early.
• A non-void method must return a value on every path, or it does not compile.
• Parameters are the variables in the heading; arguments are the values supplied at the call. They must match in number, order and (compatible) type.
• Local variables, including parameters, exist only while the method runs.

Argument passing: Java passes by value, always

A copy of the argument's value is given to the method.

• For a primitive, the copy is the number itself. Changing the parameter inside the method has no effect on the caller's variable. A method cannot swap two ints of its caller.
• For a reference, the copy is the address. The method can therefore modify the object (change an array element, call a mutator), and the caller sees the change — but if the method assigns a new object to the parameter, the caller's variable still refers to the old one.

static (class) methods

A static method belongs to the class, not to any object, and is called through the class name: Math.sqrt(2), Integer.parseInt("42"). Use static when the method needs no object state — a pure calculation on its arguments. A static method may access other static members directly, but it cannot use this or touch instance variables without an object. This is why calling an instance method from main without creating an object is a compile-time error.

A utility class is a class whose members are all static (like Math), plus public static final named constants:

public class Geometry {
    public static final double PI = 3.14159;
    public static double circleArea(double r) { return PI * r * r; }
}
// used as: Geometry.circleArea(2.0)

Overloading

Two methods in the same class may share a name provided their signatures differ — the signature is the name plus the types, number and order of the parameters. The return type is not part of the signature, so changing only the return type is not overloading; it is a compile-time error.

void show(int a)                 // OK
void show(double a)              // OK: different parameter type
void show(int a, double b)       // OK: different number of parameters
void show(double a, int b)       // OK: different order
int  show(int a)                 // ERROR: same signature as the first

When several overloads could apply, the compiler chooses the most specific match after promotion: byte and short widen to int, int widens to long, then float, then double. So show((byte)2 + 1) calls show(int) — the arithmetic has already produced an int.

The Math class

Random integer from lo to hi inclusive: (int)(Math.random() * (hi - lo + 1)) + lo. A die roll is (int)(Math.random() * 6) + 1.

Wrapper classes and Character

Each primitive has a wrapper class: Integer, Double, Character, Boolean, Long, Short, Byte, Float. They provide constants (Integer.MAX_VALUE), conversions (Integer.parseInt("42"), Double.parseDouble("3.5"), String.valueOf(42)) and let primitives be stored in collections. Autoboxing converts automatically between int and Integer.

Useful Character methods: isDigit, isLetter, isLetterOrDigit, isUpperCase, isLowerCase, isWhitespace, toUpperCase, toLowerCase.

Formatted output

System.out.printf("%-10s %5d %8.2f%n", name, qty, price);