Chapter 5 Methods

An overview

In Add2Integers:println(“This program adds two integers.”);int n1 = readInt(“Enter n1: “);

• method name: println• argument (string): “This program adds two integers.”• operation: prints the argument (string) on the console• return: no return value (void)• When the call to println is completed, the program continues

to the next statement

println(“This program adds two integers.”);int n1 = readInt(“Enter n1: “);

• method name: readInt• argument (string): “Enter n1: “• operation: prints the argument (string) on the console, then

read an integer from the user (keyboard)• return: the integer entered by the user• This method can be viewed as an expression. It returns a

value (integer). When the call to readInt is completed, the program continues to store the value (integer) to variable n1.

Beauty of methods

• You don’t need to understand how readInt is implemented. Just use it as a magic box.

• You will use readInt very often.• Most of you probably will never have to

understand how readInt is implemented.

Information hiding

Methods vs programs

• Input/output from/to the user should be part of a program, a service to a user.

• A program passes/gets arguments/results to/from a method, a service to a programmer.

• New programmers have a tendency to use input/output operations within methods when the logic of the situation calls for using arguments and results.

Method calls as expressions

Method calls that return a value can be used as terms in an expression just like variables and constants.

Example readInt(“n1: “) + readInt(“n2 “)

Math methods

Static methods from the Math class:Math.abs(x), Math.sin(x), Math.sqrt(x)Figure 5-1, p. 137

double distance = Math.sqrt(x*x + y*y);Note• you must include the class name Math when calling a

Math method.• use x*x instead of Math.pow(x, 2)

Method calls as messages

The Math methods are static methods, they belong to the class Math.

In object-oriented languages like Java, the act of calling a method is often described in terms of sending a message.

Objects communicate by sending messages.One object (the sender) invokes a method that belongs to another object

(the receiver).

Examplerect.setColor(Color.RED)sender: the current (calling) object receiver: rect object (an object of GRect)

Method calls as messages (cont.)

One object (the sender) invokes a method that belongs to another object (the receiver).

Example: rect.setColor(Color.RED)sender: the current (calling) object receiver: rect object (an object of GRect)

Pattern: receiver.methodName(arguments)

If the receiver (target object) is this (current,

calling object), the receiver can be omitted.

println(value)is the same asthis.println(value)Since the method println() is defined as a part of

the Program class. Every subclass of Program inherits this method.

Writing your own methodsvisibility type name(parameters) { method body}• visibility: private or public, keep a method private if possible.• type: data type of the return value or void if no return value.• name: use a meaningful name

Exampleprivate double celsiusToFahrenheit(double c) { implementation}

Returning a value from a method

Pattern return expression

Exampleprivate double feetToInches(double feet) { return 12*feet;}

Example: temperature conversion

/* * File: TemperatureConversionTable.java * ---------------------------------------------------- * This program creates a table of Celsius to Fahrenheit * equivalents. Lower and high limits and step are defined * as constants */

Import acm.program.*;

Public class TemperatureConversionTable extends ConsoleProgram {

public void run() { println(“Celsius to Fahrenheit table.”); for (int c = LOWER_LIMIT; c <= UPPER_LIMIT; c += STEP_SIZE) { int f = (int) celsiuToFahrenheit(c); println(c + “C = “ f + “F”); } }

/* Returns the Fahrenheit equivalent of the Celsius temperature c. */ private double celsiusToFahrenheit(double c) { return (9.0 / 5.0) * c + 32.0;

/* Private constants */ private static final int LOWER_LIMIT = 0; private static final int UPPER_LIMIT = 100; Private static final int STEP_SIZE = 5;}

Example (cont.)

Note• method celsiusToFahrenheit belongs to this

class, thus this (the receiver) can omitted.• Method println is defined as a part of

Program, which is the superclass of this class, thus this (the receiver) can be omitted.

Methods involving control statementsprivate int max(int m, int n) { if (m > n) { return m; } else { return n; }}same as return ((m > n)? m : n);return can be used at any points in a method and may

appear more than once.

Nonnumerical methods

private String weekdayName(int day) { switch (day) { case 0: return "Sunday"; case 1: return "Monday"; case 2: return "Tuesday"; case 3: return "Wednesday"; case 4: return "Thursday"; case 5: return "Friday"; case 6: return "Saturday"; default: return "Illegal weekday"; }}

Methods returning graphical object

/* A circle of radius r centered at (x,y) filled with color */private GOval createFilledCircle(double x, double y, double r,

Color color) { GOval circle = new GOval(x - r, y - r, 2 * r, 2 * r); circle.setFilled(true); circle.setColor(color); return circle;}

Useful when drawing multiple filled circles.

Predicate methodsMethods that return Boolean values.

private boolean isDivisibleBy(int x, int y) { return x % y == 0;}

Examplefor (int i = 1; i <= 100; i++) { if (isDivisibleBy(i, 7)) { println(i); }}

Testing power of 2

private boolean isPowerOfTwo(int n) { if (n < 1) return false while (n > 1) { if (n % 2 == 1) return false; n /= 2; } return true;}

Method-calling mechanicsUnderstand what happens during a method-call.Examplemain programpublic void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}

Methodprivate int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}

run

i

LOWER_LIMIT UPPER_LIMIT

0 10

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}

run

i

LOWER_LIMIT UPPER_LIMIT0 10

0

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}

run

i

LOWER_LIMIT UPPER_LIMIT0 10

0

(par) return point return valueR

R

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

0

(par) return point return valueR

R

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

n (par)

0

result 1 i 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

0

(par) return point return valueR

R

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

n (par)

0

result 1 i 1

1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

0

(par) return point return valueR

R

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

1 0! = 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

1

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

0! = 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

1

(par) return point return valueR

R

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

n (par)

1

result 1 i 1

1 0! = 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

1

(par) return point return valueR

R

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

10! = 11! = 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); }}run

i

LOWER_LIMIT UPPER_LIMIT0 10

2

private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result;}

0! = 11! = 1

Decomposition

Decompose a large task into more manageable smaller tasks. Even further decompose some subtasks into still smaller subtasks.

Decomposition strategy• Follow the structure if the real-world problem• Each subtask should perform a function that is easy

to name and describe• Each level should take responsibility for certain

details and avoid having those details percolate up to higher level

Example: Drawing a train

Pseudocode

public void run() { draw the engine draw the boxcar draw the caboose}

Arguments vs named constants

In graphical problems, it is about the information needed to draw the right picture, such as sizes and locations.

Two ways:• You can use named constants to define the

parameters of the picture• You can pass this information as arguments to each

method

Arguments vs named constants

Using named constants is easy but inflexible, e.g., the location of a boxcar may change

Using arguments is more cumbersome but easy to change

Guidelines• Use argument when caller will want to supply

different values• Use named constants when caller will be satisfied

with a single value

DrawTrain program

Assumptions• The caller will always want to supply the location of

each car.

• All train cars are the same size and have the same basic structure.

• Engines are always black.

• Boxcars come in many colors, which means the caller must supply it.

• Cabooses are always red.

DrawTrain program

Headers• private void drawEngine(double x, double y)

• private void drawBoxcar(double x, double y, Color color)

• private void drawCaboose(double x, double y)

Looking for common featuresAnother useful strategy in choosing a decomposition is

to look for features that are shared among several different parts of a program. Such common features can be implemented by a single method.

Common structure in DrawTrain• the frame for the car,• the wheels on which it runs,• a connector to link it to its neighbor.

• The engine is black and adds a smokestack, cab, and cowcatcher.

• The boxcar is colored as specified by the caller and adds doors.

• The caboose is red and adds a cupola.

You can use a single drawCarFrame method to draw the common parts of each car, as described in the text.

Algorithmic methods

Greatest common divisor problem:int gcd(int x, int y)

x, y: positive integers

gcd(49,35) = 7gcd(6,18) = 6gcd(32,33) = 1

A brute force approach

public int gcd(int x, int y) { int guess = Math.min(x,y); while (((x % guess) != 0) || ((y % guess) != 0)) { guess--; }}

• Correctness: while loop terminates if

!(((x % guess) != 0) || ((y % guess) != 0))From De Morgan’s law, it is equivalent to

((x % guess) == 0) && ((y % guess) 0= 0)Thus the final guess is a common divisor. The

program counts downward, the final guess is the first common divisor, so the greatest.

• Termination: initial guess is a positive integer, then decremented in the program. Eventually, it will reach 1, which is always a common divisor. The loop terminates.

Euclid’s algorithm

int gcd(int x, int y) { int r = x % y; while (r != 0) { x = y; y = r; r = x % y; } return y;}

• Correctness and termination: beyond the scope of this course.

• Efficiency:gcd(1000005, 1000000)

brute force: 2000000 – 8 % operationsEuclid’s: 2 % operations

gcd(1000000, 1000005)Euclid’s: 3 % operations