ITEC 120 2008spring ibarland, jdymacek

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

lect03a
role-playing function calls; scope

parameters, locals, and their scope

We'll get three volunteers, and will role-play what happens when one function calls another. Each function is its own person inside the computer; the only way to interact with the function is to pass it an argument (a number written down on a piece of paper), and get the answer returned (on another piece of paper).

In particular, the function has no idea of how you generated the number you passed to it (and it doesn't care). Conversely, you don't care how the function computes its answer; you just use the answer.

We revisit our solution to last week's lab, where we wrote toppingArea and crustArea. We've updated it a bit to add a couple of local variables (for practice).

/** Functions to calculate the area of pizza purchased, given a diameter.
 *
 * @author Ian Barland
 * @version 2007.Jan.10
 */
class PizzaServer {

  /** Calculate the area of a pizza, given its diameter.
   * @param diam The diameter of the pizza, in inches.
   * @return The area of the pizza, in square inches.
   *    (test cases omitted, to fit on one screen in class)
   */
  double pizzaArea( double diam ) {
    double radius;
    radius = diam/2;
    return 3.14 * radius * radius;
    }


  /** Calculate the are of *topping* on a pizza, given its diameter.
   *  Krusteaze pizza has 3" of crust all the way around.
   * @param diam The diameter of the pizza (in inches); must be 6 or more.
   * @return The amount of topping (in square inches)
   *    (test cases omitted, to fit on one screen in class)
   */
  double toppingArea( double diam ) {
    double toppingDiam;
    toppingDiam = diam - 2*3;
    return this.pizzaArea( toppingDiam );
    /* We subtract the part of the diameter which is crust: 3" on each side. */
    }


  /** Calculate the are of *crust* on a pizza, given its diameter.
   *  Krusteaze pizza has 3" of crust all the way around.
   * @param diam The diameter of the pizza (in inches); must be 6 or more.
   * @return The amount of crust (in square inches)
   *    (test cases omitted, to fit on one screen in class)
   */
  double crustArea( double diam ) {
    return this.pizzaArea(diam) - this.toppingArea(diam);
    }

  }

Practice We'll get three volunteers; if you want to play the role of toppingArea or pizzaArea it helps to have a calculator.
Q: I call crustArea, handing them a sheet of paper with “20” written on it. What happens?

Teacher: You'll want three bold markers, some sheets of blank paper passing and returning results, and these placards (.doc). (The two copies of pizzaArea placard is intentional: it's called twice, with a different input each time.)

Pay close attention to the way pizzaArea is called two separate time -- once with a value of 20, and once with the value of 14.

Discussion points:

• Each line of code corresponds to some action. It's hard to think so small! But thinking w/o making intuitive leaps is needed to understand just what the computer is (and is not) doing.
• Each function is a task unto itself; it's not bothered by where its inputs came from, nor what the caller intends do with the result. When writing a function, think only about the given task, not those other issues. This extremely reductionist mode of thinking is exceedingly powerful, when creating a large system of tightly interconnecting parts, like a program, a critical essay, or other logical argument¹
• Java actually does something, when it encounters a variable-declaration: the function writes down the name next to an empty box, on its sheet of paper (it's environment).
• There are several names “diam” going on. But each function's parameter is local to that function; so there are really several variables that all have the same name.
• Even if each function had declared and initialized its own local variable named “someNumber”, they would have been different variables. A function cannot see names written down on other function's papers (“environments”). Put another way: The scope of a local variable is only the function in which it's declared.
• A parameter is local to its function — it's a local variable which is declared in the signature, and initialized for you, when the function is called.
• even if two functions both happen to use the parameter name diam, it's really two entirely different variables.
• We say the scope of the parameter (and, a local variable) is from its opening-curly-brace to the closing-curly-brace; if you try to use the name outside of that region you'll get some error along the lines of "unknown variable".

Review: syntax-week2—Java Syntax: week 2

Applied Example (inside, say, class Emcee):

  /** How many characters are needed, to print somebody's name?
   * @param fname The person's first name.
   * @param lname The person's last  name.
   * @return the number of characters needed to print the full name.
   *  Examples, if djMo were an Emcee:
   *    djMo.charsNeeded( "Jane", "Doe" ) =                 
   *    djMo.charsNeeded( "Jane", ""    ) =                 
   *    djMo.charsNeeded(     "", ""    ) =                 
   */
  int charsNeeded( String fname, String lname ) {
    return                 ;
    
    }

Note that we don't yet know how to write correct code for the above function. (How do we sometimes add 1 for the space between the two names, and sometimes not?) We'll be better able to do this in a couple of days, after talking about booleans and if-else.

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

©2008, Ian Barland, Radford University Last modified 2008.Jan.24 (Thu)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu