CISC 1115 Lecture Methods

CISC 1115
Introduction to Programming Using Java
Methods

Reading from the Text

Chapter 4

All of Chapter 4 should be readable

Methods

Overview

Simplistically speaking, a method is a block of code that has been assigned a name
- The code can be executed by calling calling the method via its name
- When a method is called:
  - the calling code suspends
  - the code in the method begins to execute
  - when the code in the method finishes executing, the calling code continues its execution
To carry out its task the method may need additional information from the calling code; these are passed to the method as arguments. Some examples:
- if we have a method to calculate a square root, we need the number whose square root we want
- if we have a method that calculates an average, we need the input grades
- if we have a method that prints a value to the screen, we need the value
- calculating the current time of day requires no additional input from the calling code
Similarly, if the method's task was to calculate a value, it needs to pass that value back to the calling code. Continuing with the above examples:
- if we have a method to calculate a square root, we need to pass back the value of the square root to the calling code
- if we have a method that calculates an average, we need to pass back the average
- if we have a method that prints a value to the screen, no value needs to be passed back
- we pass back the time of day to the calling code

We thus see there are the following components to using a method:

the call or invocation
the passing of values to the method
the execution of the method's code
the return of control to the calling code
the passing back of a value

Motivations for Methods

Elimination of Duplicate/Redundant Code

Imagine the code to calculate a letter grade from a numerical grade. This may crop up several times in a student-grading system: for term projects, final exams, quizzes, etc. Rather than repeating the set of conditionals each time, we move it into a method and call it from any location where that logic is used.

Relocation of Distracting Code

Suppose we wanted to print out the output of our grading program in some fancy manner with borders and blank lines, etc. Rather than having all that appear in the middle of our grade calculation logic, we again move it into a method and call it from the location at which it was originally meant to appear

Isolation of Complex, or Esoteric Code

There are various mathematical techniques for calculating square roots, many of them quite sophisticated. Rather than placing these into your code, they are isolated into methods that can be simply called

Assigning a Name to a Task

This is the underlying notion behind methods — it is a means of organizing code into manageable-sized tasks with well-defined, descriptive name.

More Examples of Methods

Problem statements often have 'subproblems' or subtasks -- portions that can be isolated and solved independently of the rest of the problem.
- ExamGrader
  - The calculation of the average
  - Given an average, determining the letter grade
  - Processing a single student; calculation of the average
- WeightedAverager
  - calculation of a weighted average
- Payroll
  - Calculating the amount earned; processing each employee
  - Determination of bonus amount; determination of weeks of vacation
- Divisibility
  - Deciding whether a number is divisible by 17
Isolating the code for a subtask makes the code much easier to follow and maintain
The programming construct for this is known as a method, and the code associated with a method is called a method definition.
- The term method is meant to be intuitive … a method is a way of doing something; in our context a task or subtask
Benefits of methods:
- Code readability
  - Assigning a meaningful name to a method provides context and understanding to the programmer looking at the code
    - Seeing a call to a method named calculateSemesterAverage is more meaningful than looking at a sequence of statements that actually performs the calculation
- Code organization
  - Breaking up a large, complex piece of software into smaller tasks makes the program easier to:
    - manage
    - build
      - Breaking up large programs into smaller units like methods permits us to compile them individually.
      - When making a change (e.g. when fixing a bug), it may not be necessary to recompile everything.
    - debug
      - Breaking the program into methods allows us to examine what each method does somewhat independently of the rest of the program. This makes finding errors more tractable.
- Code reuse
  - Same method can be called/invoked from several places in program / company's project / universally
- Project organization
  - Individual (or related groups of) methods can be assigned to different members of a project team depending on their availability, expertise, preferences.
Augenstein's rules:
- if you can give it a name or describe it in a sentence, make it a method
- if you're not sure how to write it, make it a method
  - come back to it later, or farm it out
A rough rule of thumb (part 1)
- If you can describe it in a sentence, use the verb as the name of the method
- Part 2 will come later
Analogy of a method of code to a recipe

Calling Existing Methods (From Other Classes)

P04.1 Rounder

Write a program that prompts the user for a double and uses the round method of the Math class to print the integer resulting from rounding the double.

import java.util.*;
import java.io.*;

public class Rounder {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(System.in);

                System.out.print("Enter a double: ");
                double d = scanner.nextDouble();

                System.out.println(d + " rounds to " + Math.round(d));
        }
}

Interactive Session

Here is a sample execution of the program.
User input is in bold.

Enter a double: 23.1
23.1 rounds to 23

P04.2 Pythagoras

Write a program that finds prompts the user for the side of a square and prints the length of the diagonal.

import java.util.*;

public class Pythagoras {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(System.in);

                System.out.print("Enter the (integer) length of the side of the square: ");
                int side = scanner.nextInt();

                double diagonal = Math.sqrt(2) * side;

                System.out.println("The length of the diagonal of a square with a side of length " + side + " is " + diagonal);
        }
}

Interactive Session

Here is a sample execution of the program.
User input is in bold.
Enter the (integer) length of the side of the square: 1
The length of the diagonal of a square with a side of length 1 is 1.4142135623730951

Methods from other Classes

Part of the organization mentioned above
- Methods that 'belong together' are grouped together in the same class
Calling/invoking a method from another class requires the method name be prefixed with the name of either the class or an object of that class
- Name of the class
  - If the method can perform its task simply with the information supplied by the user (call), the method is called using the name of the class
    - Math.abs(i)
    - Math.round(d)
    - Math.sqrt(d)
    In all of the above, the method can operate simply by knowing the number sent as the argument by the caller.
- Object of the class
  - On the other hand, some methods require more context; in such cases, an object of the class (containing such context) is used
    - scanner.nextInt()
      - our Scanner objects until now were all based on the keyboard; i.e., the input comes from the keyboard. We will soon see that input can come from other places as well … in particular files on disk. When creating a Scanner object, one specifies where the input should come from; that is then maintained within the particular created object (e.g. scanner). Thus when calling nextInt on an object created from the keyboard, the input will come from the keyboard; from a file, the input will come from a file.
If the above is unclear to you, don't worry:
- it will become clearer as we progress in our coding skill, and see more examples
- in 1115, calling methods of other classes will be limited to a small set of repeatedly-used methods

Writing Your own Methods — Anatomy of a Method I

P04.3 HelloWorld

Redo HelloWorld using a method for the display of Hello world

Code

class HelloWorld {
        public static void main(String [] args) {
                displayHelloWorld();
        }

        public static void displayHelloWorld() {
                System.out.println("Hello world");
        }
}

Notes

At the very least, a method definition consists of

A name (displayHelloWorld)
- Like variables, we use a meaningful name
The method name and necessary boilerplate form the first line of the method and is called the method header
- As we have seen with main (which is a method), we will require the public static boilerplate
The code corresponding to the subtask (the code surrounded by {}'s following the method header)
- This code is called the method body (analogous to a loop body)
Once defined, we can use the method (much as we used the methods println(), next(), etc), by calling, (or invoking, the method.
- A method is called by writing the name of the method, and following it with a (possibly empty) parenthesized list
- Since the method belongs to our class (as opposed to println or next which belong to System.out and Scanner respectively), we do not need to prefix the method name with the class to which the method belongs.
```
public static void displayHelloWorld() {		// Note the similarity to the first line of 'main' 
	…
}
		
```
Once again, main is also a method
- Every program must contain a main method
- Program execution begins with the first statement within main and terminates after the last statement of main has been executed.

Stdout
Hello world

P04.4 AsciiA

Write a program containing a method, printA, that prints an 'ASCII art' letter A:

      A      
     A A     
    A   A    
   AAAAAAA   
  A       A  
 A         A 
A           A

Code
public class AsciiA {
   public static void main(String [] args) {
      printA();
   }
      
   public static void printA() {
      System.out.println("      A      ");
      System.out.println("     A A     ");
      System.out.println("    A   A    ");
      System.out.println("   AAAAAAA   ");
      System.out.println("  A       A  ");
      System.out.println(" A         A ");
      System.out.println("A           A");
   }
}

Stdout

A A A A A AAAAAAA A A A A A A

Lifecycle of a Method

All code executes within the body of a method
- Until now, all our code has been written in the main method.
When a method calls another method, we speak of the
- calling method (or caller)
- method being called, (or callee)
  - We have in Program 4.1, main calling processOneStudent; therefore main is the caller, and processOneStudents the callee.
When a method is called:
- the calling method (the caller) suspends execution, control passes to the callee, and the callee begins execution at its first statement.
- after the last statement of the callee is executed, control passes back to the caller and it continues execution from the point where it was suspended.

Multiple Methods; Method Composition

Program will typically have more than one method
Furthermore methods will typically call other methods; i.e., methods are not just called from main
- Calling one method from within another is a technique known as composition
  - Composition allows the programmer to create methods of increasingly power and complexity from simpler, already-existing methods.

P04.5 Box

Write a program that prints the following figure:

!!!!!
*****
*****
*****
*****
*****
!!!!!

The program should contain the following methods:

printBox — prints the entire figure
printBorder — prints a line of 5 !'s
printStars — prints a line of 5 *'s
printFiveLinesOfStars — prints five (5) lines of stars by calling printStars within a for loop

Code

public class Box {
        public static void main(String [] args) {
                printBox();
        }

        public static void printBox() {
                printBorder();
                printFiveLinesOfStars();
                printBorder();
        }

        public static void printBorder() {
                System.out.println("!!!!!");
        }

        public static void printFiveLinesOfStars() {
                for (int i = 1; i <= 5; i = i + 1)
                        printStars();    
        }

        public static void printStars() {
                System.out.println("*****");
        }
}

Notes

Note the re-use of the printBorder method
The use of composition also makes the code much more readable

Stdout

!!!!! ***** ***** ***** ***** ***** !!!!!

Parameters and Arguments — Anatomy of a Method II

We will often need to send information to a method. Methods can accept arguments that are assigned to parameters.

As it currently stands, a method that we wrote to print a form letter would print the same exact letter each time its called.
To increase the flexibility of such a method, we would like to be able to pass in personalized information, such as a name, which could then be assigned to a varible in the method..
The name variable could then be used by the method body.
An element of data passed to a method is known as an argument, whicle the variable it is assigned to within the methd is called a parameter.
- Arguments are passed to the method as a comma-separated list in the call:
```
printFormLetter("Mr.", "Gerald", "Weiss");
				
```
- The parameters (which are variables of the called method) are declared as a comma-separated list between the ()'s in the method header.
```
public static void printFormLetter(String salutation, String firstName, String lastName) { 
	… 
}
				
```
- Each argument may be a literal or a variable:
```
printFormLetter("Mr.", "Gerald", "Weiss");	// all literals
printFormLetter(sal, first, last);			// all variables
printFormLetter("Mr.", first, last);		// mixture
				
```
- The parameter variable bears no relation to any variable in any other method and thus the same variable name may be used in more than one method
  - This is true of ALL variables in a method — the variables in two methods are unrelated, even if two variables in two different methods have the same name

P04.6 FormLetter

Write a program containing a method printFormLetter. printFormLetter accepts two String arguments, representing a first and last name, and uses it to produce a 'personalized' form letter. Have main print out two copies of the form letter to two different people.

Code

public class FormLetter {
        public static void main(String [] args) {
                printFormLetter("Mr.", "Gerald", "Weiss");
                System.out.println();
                System.out.println();
                printFormLetter("Professor", "David", "Arnow");
        }

        public static void printFormLetter(String salutation, String first, String last) {
                System.out.println("Dear " + salutation + " " + last + ","); 
                System.out.println();
                System.out.println("    Hello " + first + ", we would like to inform you of our new ");
                System.out.println("chain of coffee houses in your area, geared to people like you. ");
                System.out.println(first + ", for a limited time, you can receive your own ");
                System.out.println("membership card, entitling you to 10% off your first 5 purchases, as well as a ");
                System.out.println("host of special offers. So hurry up, " + first + " and reply today!");  
        }
}

Notes

Notice how the order of the arguments must match the order of the parameters
- If the types are different, and the arguments and para,eters don't match up, a compiler error will occur
- In the above case, where they are all String, no compilation error is produced; insatead this will result in a logic error.

Stdout

Dear Mr. Weiss, Hello Gerald, we would like to inform you of our new chain of coffee houses in your area, geared to people like you. Gerald, for a limited time, you can receive your own membership card, entitling you to 10% off your first 5 purchases, as well as a host of special offers. So hurry up, Gerald and reply today! Dear Professor Arnow, Hello David, we would like to inform you of our new chain of coffee houses in your area, geared to people like you. David, for a limited time, you can receive your own membership card, entitling you to 10% off your first 5 purchases, as well as a host of special offers. So hurry up, David and reply today!

'Value'-Returning Methods — Anatomy of a Method III

Methods often calculate results which must be passed back to the caller. A method can have a return value

we can use expressions to perform simple calculations
however, more complicated logic may require more than a single expression, or a conditional, or a loop; and we will often want to make a method out of such a calculation
- for example, the calculation of a square root, or a letter grade, or a sum of a large set of numbers
the result of this calculation should be returned to the caller (after all the caller made the call to obtain that value)
- this result is known as the return value of the method
- the value (which can be an arbitrary expression) is returned using the return statement
```
public static int max(int x, int y) {
	int result;
	if (x > y) 
		result = x;
	else
		result = y;
	return result;
}
				
```
- There can be more than one return in the method body — here is an alternative yet functionally equivalent version of max:
```
public static int max(int x, int y) {
	if (x > y) 
		return x;
	else
		return y;
}	
				
```
- A value-returning method MUST have at least one return statement (i.e., something MUST be returned from the method)

the type of the return value (known as the (return) type of the method is declared in the method header

public static double sqrt(int number) { … }
public static char calcGrade(int average) { … }
public static int sumOf(20, 75) { … }  /sums up the numbers from 20 to 75

The returned value is passed back to the caller and is typically used as an operand in an expression, assigned to a variable, or printed.
```
d = 2 * sqrt(x);
char grade = calcGrade(avg); 
System.out.println(sumOf(20, 75));
		
```
Methods that do not return a value are said to be void-returning methods (void meaning 'nothing'), and are said to have a void return type.
- void methods may or may not have (one or more) return statements.
- As we've seen, reaching the closing brace (}) of the method body (i.e., executing the last statement of the method) has the same effect as a return statement.

P04.7 Grader

Rewrite the grading program, adding a first and last name, and using the following methods:

void processStudent(Scanner scanner)
double calcAverage(int midterm, int finalExam)
char calcGrade(double average)

Code

import java.util.*;

public class Grader {
	public static void main(String [] args) {
		Scanner scanner = new Scanner(System.in);

		System.out.println("Number of students to process: ");
		int numStudents = scanner.nextInt();

		for (int i = 1; i <= numStudents; i = i + 1)  
			processOneStudent(scanner);
	}

	public static void processOneStudent(Scanner scanner) {
		System.out.print("Last name: ");
		String lastName = scanner.next();
		System.out.print("First name: ");
		String firstName = scanner.next();
		System.out.print("Midterm: ");
		int midterm = scanner.nextInt();
		System.out.print("Final: ");
		int finalExam = scanner.nextInt();
		double average = calcAverage(midterm, finalExam);
		char grade = calcGrade(average);
		System.out.println("average: " + average + " grade: " + grade);
	}

	public static double calcAverage(int midterm, int finalExam) {
		return (midterm + finalExam) / 2.0;
	}

	public static char calcGrade(double average) {
		char grade;
		if (average >= 90)
			grade = 'A';
		else if (average >= 80)
			grade = 'B';
		else if (average >= 70)
			grade = 'C';
		else if (average >= 60)
			grade = 'D';
		else
			grade = 'F';
		return grade;
	}
}

Notes

Keyboard input is performed in main as well as processOneStudent, and thus the Scanner object is opened in main and passed to processOneStudent as an argument
- An (unattractive) alternative would be restrict scanner to main, read in the keyboard data (i.e., last name, first name, etc) in the loop bpdy and pass that data to processOneStudent
  - The reason it's unattractive is because logically, reading in the data for the student is part of its processing, and thus rightly belongs in the processOneStudent method.

Stdin

2 Weiss Gerald 80 95 Arnow David 65 75

Stdout

Last name: First name: Midterm: Final: average: 87.5 grade: B Last name: First name: Midterm: Final: average: 70.0 grade: C

Interactive Session

Here is a sample execution of the program.
User input is in bold.

2
Last name: Weiss
First name: Gerald
Midterm: 80
Final: 95
average: 87.5 grade: B
Last name: Arnow
First name: David
Midterm: 65
Final: 75
average: 70.0 grade: C

An Introduction to Some Advanced Concepts

p04.8 ASCIIArt

Write a method printASCIIArt(String s) that accepts a String argument and prints it as ASCII art

Code

import java.util.*;

public class AsciiArt {
     public static void main(String [] args) {
          // main is acting as a test driver, providing the ability to test the various letters
          Scanner scanner = new Scanner(System.in);

          System.out.print("string? ");
          String s = scanner.next();

          printASCIIArt(s);
     }   

     public static void printASCIIArt(String s) {
          for (int i = 0; i < s.length(); i = i + 1)
               printASCIIChar(s.charAt(i));
     }   

     public static void printASCIIChar(char c) {
          switch (c) {
               case 'A': printASCIIA(); break;
               case 'B': printASCIIB(); break;
               case 'C': printASCIIC(); break;
               case 'D': printASCIID(); break;
			…
               case 'Y': printASCIIY(); break;
               case 'Z': printASCIIZ(); break;
               case ' ': printASCIIBlank(); break;
               default: printUnknown(); break;
          }   
     }   

     …

     public static void printASCIIA() {
          System.out.println("     AAA     ");
          System.out.println("    A   A    ");
          System.out.println("   A     A   ");
          System.out.println("   AAAAAAA   ");
          System.out.println("  A       A  ");
          System.out.println("  A       A  ");
          System.out.println("  A       A  ");
     }

     public static void printASCIIB() {
          System.out.println("  BBBBBB     ");
          System.out.println("  B     B    ");
          System.out.println("  B     B    ");
          System.out.println("  BBBBBB     ");
          System.out.println("  B     B    ");
          System.out.println("  B     B    ");
          System.out.println("  BBBBBB     ");
     }

     …

     public static void printASCIID() {
          // Test stub
          System.out.println("             ");
          System.out.println("             ");
          System.out.println("             ");
          System.out.println("     D       ");
          System.out.println("             ");
          System.out.println("             ");
          System.out.println("             ");
     }

     public static void printASCIIE() {
          System.out.println("             ");
          System.out.println("             ");
          System.out.println("             ");
          System.out.println("     E       ");
          System.out.println("             ");
          System.out.println("             ");
          System.out.println("             ");
     }

     public static void printASCIIF() {System.out.println("F goes here");} // Even shorter test stub
     public static void printASCIIG() {System.out.println("G goes here");} // Even shorter test stub
     …
     public static void printASCIIY() {System.out.println("Y goes here");} // Even shorter test stub
     public static void printASCIIZ() {System.out.println("Z goes here");} // Even shorter test stub

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

     public static void printUnknown() {
          System.out.println("   ?????     ");
          System.out.println("  ?     ?    ");
          System.out.println("       ?     ");
          System.out.println("      ?      ");
          System.out.println("     ?       ");
          System.out.println("             ");
          System.out.println("     ?       ");
     }
}

Notes

How do we extract the individual characters of the String argument?
- Methods of other classes
How do we test this?
- How do we get the methods for the individual letters?
  - test stubs
- How do we supply test strings to the method?
  - test drivers

Stdin

BYE!

Stdout

string? BBBBBB B B B B BBBBBB B B B B BBBBBB Y goes here E ????? ? ? ? ? ? ?

Interactive Session
string? BYE!

  BBBBBB     
  B     B    
  B     B    
  BBBBBB    
  B     B  
  B     B 
  BBBBBB 
Y goes here
             
            
           
     E    
             
            
           
   ?????     
  ?     ?   
       ?    
      ?     
     ?     
          
     ?

A Program With Potential

P04.8 Payroll

Write a program that reads in an employee's last name, first name (strings), hours worked, and hourly rate (integers), calculates the gross wages, federal tax, state tax, and net earnings, and prints the results. Federal and state tax both use the same tax table:

Amount % tax
Up to and including $200 0%
$201 up to and including $400 10%
$401 and up 15%

Amount	% tax
Up to and including $200	0%
$201 up to and including $400	10%
$401 and up	15%

Federal tax is calculated first and deducted from the gross earning; the remainder is then subject to state tax

Code

import java.util.*;

public class Payroll {
        public static void main(String [] args) {
                Scanner scanner = new Scanner(System.in);

                System.out.print("last name: ");
                String lastName = scanner.next();

                System.out.print("first name: ");
                String firstName = scanner.next();

                System.out.print("rate: ");
                int rate = scanner.nextInt();

                System.out.print("hours: ");
                int hours = scanner.nextInt();

                int gross = calculateGross(hours, rate);
                int federalTax = calcTax(gross);
                int net = gross - federalTax;
                int stateTax = calcTax(gross);	// What's the bug?
                net = net - stateTax;

                printReport(lastName, firstName, hours, rate, gross, federalTax, stateTax, net);
        }

        public static int calculateGross(int hours, int rate) {return hours * rate;}

        public static int calcTax(int amount) {
                if (amount <= 200)
                        return 0;
                else if (amount <= 400) 
                        return (int)(amount * .10);
                else 
                        return (int)(amount * .15);
        }

        public static void printReport(String lastName, String firstName, int hours, int rate, int gross, int federalTax, int stateTax, int net) {
                System.out.println();
                System.out.println();
                System.out.println("*** Payroll Report  for " + lastName + ", " + firstName + " ***");
                System.out.println();
                System.out.println(hours + " hours worked @ $" + rate + " / hr");
                System.out.println();
                System.out.println("Gross wages: $" + gross);
                System.out.println();
                System.out.println("--- Witholdings ---");
                System.out.println("Federal tax: $" + federalTax);
                System.out.println("State tax  : $" + stateTax);
                System.out.println();
                System.out.println("Net earnings: $" + net);



        }
}

Stdin

Weiss Gerald 20 32

Stdout

last name: first name: rate: hours:

*** Payroll Report  for Weiss, Gerald ***

32 hours worked @ $20 / hr

Gross wages: $640

--- Witholdings ---
Federal tax: $96
State tax  : $96

Net earnings: $448

Interactive Session

Here is a sample execution of the program.
User input is in bold.
last name: Weiss
first name: Gerald
rate: 20
hours: 32

*** Payroll Report for Weiss, Gerald ***

32 hours worked @ $20 / hr

Gross wages: $640

--- Witholdings ---
Federal tax: $96
State tax : $96

Net earnings: $448

Future Work

Lots more employees
- printing employees in sorted order
- finding employee with highest earnings
- cumulative reports for company
Not having to enter data from the keyboard
All sorts of additional calculations
- weekend hours and overtime
- social security, local taxes, medical insurance

CISC 1115
Introduction to Programming Using Java
Methods

Reading from the Text

Chapter 4

Methods

Overview

Motivations for Methods

Elimination of Duplicate/Redundant Code

Relocation of Distracting Code

Isolation of Complex, or Esoteric Code

Assigning a Name to a Task

More Examples of Methods

Calling Existing Methods (From Other Classes)

Methods from other Classes

Writing Your own Methods — Anatomy of a Method I

Lifecycle of a Method

Multiple Methods; Method Composition

Parameters and Arguments — Anatomy of a Method II

'Value'-Returning Methods — Anatomy of a Method III

An Introduction to Some Advanced Concepts

A Program With Potential

Future Work

Files used in Lecture 4

Lab for Lecture 4

CISC 1115 Introduction to Programming Using Java Methods

Reading from the Text

Chapter 4

Methods

Overview

Motivations for Methods

Elimination of Duplicate/Redundant Code

Relocation of Distracting Code

Isolation of Complex, or Esoteric Code

Assigning a Name to a Task

More Examples of Methods

Calling Existing Methods (From Other Classes)

Methods from other Classes

Writing Your own Methods — Anatomy of a Method I

Lifecycle of a Method

Multiple Methods; Method Composition

Parameters and Arguments — Anatomy of a Method II

'Value'-Returning Methods — Anatomy of a Method III

An Introduction to Some Advanced Concepts

A Program With Potential

Future Work

Files used in Lecture 4

Lab for Lecture 4

CISC 1115
Introduction to Programming Using Java
Methods