ITEC 120 2008spring ibarland, jdymacek

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

lect06c
Classes are Types
and references are values

Review Exercise

• What is the purpose of a constructor?
• How is the signature for a constructor different from most signatures? (2 ways)
• How is calling a constructor different from calling regular functions? (What Java keyword do you use?)

Classes are Types

Compare:

Math.sqrt(25.0)

// versus:

double x;      // declare a variable (a box) labeled `x`
x = 25.0;      // initialize x (put a value into the box)
Math.sqrt(x);  // use (the contents of the box labeled) `x`

Now compare:

(new PizzaServer()).pizzaArea(25)

// versus:

PizzaServer jo;         // declare a variable (a box) labeled `jo`
jo = new PizzaServer(); // initialize jo (put a value into the box)
jo.pizzaArea(25);       // use (the contents of the box labeled) `jo`

Note that: Calling a function (possibly a constructor) and getting a result back is a different task from storing that result in a variable.

Methods which take objects as inputs

  /** Does this PizzaServer make more money (per hour) than some rival?
   * @param rival The PizzaServer to compare against.
   * @return true if this's salary is strictly bigger than rival's salary.
   */
  boolean hasHigherSalaryThan( PizzaServer rival ) {
    return true; //  A stub function; will write the rest later.
    }

• Create instances of PizzaServers (you can even use BlueJ's Object bench to test fixture).
• Call the function several times. Situations to test:
  • the salaries are equal (and we ask the first PizzaServer)
  • the PizzaServer we ask has a higher salary;
  • the PizzaServer we ask has a lower salary;
  • the salaries are equal (and we ask the second PizzaServer, just to be complete).

Now that we've recorded some test cases (even though they don't currently pass), we can go back and actually implement the function:

• What pieces of information do we have to work with?
  Only the parameter rival … and this.
• Both of these happen to be of type PizzaServer; what pertinent questions can we each ask each of them?
  getSalary (which will return a number)
• How do we compare two numbers?
  >, with the pertinent number on either side. > will give us back a boolean.

  /** Does this PizzaServer make more money (per hour) than their rival?
   * @param rival The PizzaServer to compare against.
   * @return true if this's salary is strictly bigger than rival's salary.
   */
  boolean hasHigherSalaryThan( PizzaServer rival ) {
    return (this.getSalary() > rival.getSalary());
    }

Note that the series of questions we asked can make sense when writing the body of any method. It's the last step of The Design Recipe!

What happens, when the function is called?

We will step through this function. In fact, we can put a stop-sign at the line of code inside hasHigherSalaryThan, and run our tests. We've seen the debugger window before. Note that under fields we see this's fields, and under local variables we see the parameter rival.

Especially note that the value of rival is “object reference”. This means that really, rival is a variable whose value is an arrow pointing to a particular object. This is subtly different than the variable storing the object itself; we'll see exactly why, later.

Imaging the following is typed at the Code Pad:

1. PizzaServer p1;
2. p1 = new PizzaServer( "Radford" );
3. 
4. PizzaServer p2;
5. p2 = new PizzaServer( "Pulaski" );
6. 
7. p1.hasHigherSalaryThan( p2 );
8. 
9. p1.hasHigherSalaryThan( p1 );

Let's role-play what happens on each line. As the instructor, I'll be the code pad. Line 1 declares a variable (local to me). Line 2 actually (a) calls a constructor -- we need a volunteer to be a PizzaServer object -- and (b) initializes my local variable with a reference to that new object (a piece of string attached to that volunteer). Note that our volunteer has a sheet attached to them, listing all their fields.
Lines 4 and 5 are similar.

Line 7 is interesting:

• call the method (bring out a new sheet of paper), with the parameter rival: the value of that parameter is (a copy of) the reference (the piece of string) to p2. We'll need a volunteer to act as the function, holding a paper with all its local variables.
• New fact: really, this is just another parameter -- one whose value is a reference to the object being invoked.
• Now, the hasHigherSalaryThan volunteer merely follows the instructions inside the method. This might involve calling another method.

Finally, in line 9, the same thing happens. The only thing to raise an eyebrow is that the parameters (local variables) rival and this happen to hold the same reference inside of them. That's not a problem; it's no different than having two int variables which both happen to contain 17.

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