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). Example rect.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 as this.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 methods visibility 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 Example private double celsiusToFahrenheit(double c) { implementation }

Returning a value from a method Pattern return expression Example private 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 ; /* 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 statements private 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 methods Methods that return Boolean values. private boolean isDivisibleBy(int x, int y) { return x % y == 0; } Example for (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 mechanics Understand what happens during a method-call. Example main program public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } Method private 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_LIMITUPPER_LIMIT 0 10

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

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } run i LOWER_LIMITUPPER_LIMIT (par)return pointreturn value R R

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } run i LOWER_LIMITUPPER_LIMIT010 0 (par)return pointreturn value R R private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } n (par) 0 result 1i1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } run i LOWER_LIMITUPPER_LIMIT010 0 (par)return pointreturn value R R private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } n (par) 0 result 1i1 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } run i LOWER_LIMITUPPER_LIMIT010 0 (par)return pointreturn value R 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_LIMITUPPER_LIMIT010 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_LIMITUPPER_LIMIT010 1 (par)return pointreturn value R R private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } n (par) 1 result 1i1 1 0! = 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } run i LOWER_LIMITUPPER_LIMIT010 1 (par)return pointreturn value R R private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } 1 0! = 1 1! = 1

public void run() { for (int i = LOWER_LIMIT; i <= UPPER_LIMIT; i++) { println(i + “! = “ + factorial(i)); } run i LOWER_LIMITUPPER_LIMIT010 2 private int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } 0! = 1 1! = 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 features Another 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) = 7 gcd(6,18) = 6 gcd(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( , ) brute force: – 8 % operations Euclid’s: 2 % operations gcd( , ) Euclid’s: 3 % operations