Skip to main content

ITSC 1213 - Introduction to CS 2 How to Design Programs with Object Oriented Programming

Nadia Najjar, Dhruv Dhamani

Section 6.9 Calling Methods With Parameters

In the previous section, we used simple methods like forward() and turnRight() to make the player move around. You may have noticed that forward() always moves the same distance (10 pixels), and turnRight() and turnLeft() always turn at right angles (90 degrees). This is a little limiting. What if we wanted the player to move 100 pixels? or move diagnoally? This requires different distance length and smaller/larger angles. We can add complex methods in the Player class that let you specify the number of pixels to move forward or the number of degrees to turn. These values that you can give to methods to help them do their job are called arguments or parameters.
🔗
The parentheses () after method names are there in case you need to give the method actual parameters or arguments (some data) to do its job. For example, we can give the argument 100 in forward(100) to make the player go forward 100 pixels or the argument 30 in turn(30) to make the player turn 30 degrees instead of 90 degrees.
🔗

Note 6.9.1.

object.method(arguments); is used to call an object’s method and give it some arguments (actual parameters) to do its job.
🔗
🔗
Although some people use the words parameters and arguments interchangeably, there is a subtle difference. When you create your own method, the variables you define for it are called formal parameters. When you call the method to do its job, you give or pass in arguments or actual parameters to it that are then saved in the parameter variables. So, in the definition of the forward method, it has a parameter variable called distance, and in the call to forward(100), the argument is the value 100 which will get saved in the parameter variable pixels. You will learn to write your own methods in Unit 5. In this unit, you will learn to call methods that are already written for you.
🔗
// Method call
player1.forward(100); // argument is 100

// Method definition written for you
public void forward(int distance) // parameter distance
...

Subsection 6.9.1 Tracing Methods

You will not write your own methods until Unit 5, but you should be able to trace and interpret method calls like below.
🔗
Here is another version of the Old MacDonald Song with a more powerful abstraction. The method verse has 2 parameters for the animal and the noise it makes, so that it can be used for any animal. Use the Code Lens button or this Java visualizer to step through the code.
🔗
🔗

Subsection 6.9.2 Practice

Checkpoint 6.9.2.

Add another verse in main that calls the method verse with a different animal and noise.
🔗
🔗

Checkpoint 6.9.3.

2-4-6: What does the following code print out?
🔗
public class MethodTrace
{
  public void square(int x)
  {
      System.out.print(x*x);
  }
  public void divide(int x, int y)
  {
      System.out.println(x/y);
  }
  public static void main(String[] args) {
      MethodTrace traceObj = new MethodTrace();
      traceObj.square(5);
      System.out.print(" and ");
      traceObj.divide(4,2);
  }
 }
  • 25 and 2
  • Correct.
  • 25 and .5
  • The order of the arguments to the divide(x,y) method will divide x by y and return an int result.
  • 2 25
  • The square(x) method is called before the divide(x,y) method.
  • 25 2
  • The main method prints out " and " in between the method calls.
  • Nothing, it does not compile.
  • Try the code in the visualizer link below.
🔗
Try this visualization to see this code in action.
🔗

Checkpoint 6.9.4.

2-4-8: Consider the following methods:
🔗
public void inchesToCentimeters(double i)
{
    double c = i * 2.54;
    printInCentimeters(i, c);
}

public void printInCentimeters(double inches, double centimeters)
{
    System.out.print(inches + "-->" + centimeters);
}
Assume that the method call inchesToCentimeters(10) appears in a method in the same class. What is printed as a result of the method call?
🔗
  • inches –> centimeters
  • The values of the variables inches and centimeters should be printed out, not the words.
  • 10 –> 25
  • Two doubles should be printed, not two ints, and the centimeters should be 25.4
  • 25.4 –> 10
  • Inches should be printed before centimeters.
  • 10 –> 12.54
  • c = 10 * 2.54 = 25.4, not 12.54.
  • 10.0 –> 25.4
  • Correct! centimeters = 10 * 2.54 = 25.4.
🔗

Checkpoint 6.9.5.

2-4-9: Consider the following methods, which appear in the same class.
🔗
public void splitPizza(int numOfPeople)
{
    int slicesPerPerson = 8/numOfPeople;
    /* INSERT CODE HERE */
}

public void printSlices(int slices)
{
    System.out.println("Each person gets " + slices + " slices each");
}
Which of the following lines would go into /* INSERT CODE HERE */ in the method splitPizza in order to call the printSlices method to print the number of slices per person correctly?
🔗
  • printSlices(slicesPerPerson);
  • Correct! If you had 4 people, slicesPerPerson would be 8/4=2 and printSlices would print out “Each person gets 2 slices each”.
  • printSlices(numOfPeople);
  • If you had 4 people, this would print out that they get 4 slices each of an 8 slice pizza.
  • printSlices(8);
  • This would always print out 8 slices each.
  • splitPizza(8);
  • This would not call the printSlices method.
  • splitPizza(slicesPerPerson);
  • This would not call the printSlices method.
🔗
🔗
You have attempted of activities on this page.
🔗
PrevTopNext