CS 10: Spring 2014

Lecture 2, March 26

Code discussed in lecture

Short Assignment 1

Short Assignment 1 is due Friday.

A quick look at a Java class, continued

Last time, we looked at the instance variables and some of the methods in the Counter class in Counter.java. Today, we continue.

The next method in the Counter class is toString:

  /**
   * Return a String representation with at least 2 digits, padding with a
   * leading 0 if necessary.
   * 
   * @return a String representation of the counter with at least 2 digits.
   */
  public String toString() {
    DecimalFormat fmt = new DecimalFormat(FORMAT);  // use at least 2 digits
    return fmt.format(myValue);

The toString method is called automatically whenever we need the string representation of an object. Notice that it returns a String. If we don't supply the toString method in a class definition and we try to convert the object to a string, we just get the object's address in memory, in hexadecimal (base 16), which is rarely useful. Here, the toString method converts the counter's value to a character string of at least two digits. It uses the class DecimalFormat that we imported up at the top of the file. The toString method first creates a DecimalFormat object with the Java keyword new. The only way to create a new object in Java is via the keyword new. The class variable FORMAT is passed to the constructor for DecimalFormat.

The new operator does three things:

  1. It allocates memory for the object.
  2. It runs a constructor on the object being created.
  3. It returns the address of the object in memory. We call this address a reference to the object.

Let's take a look at the variable fmt. It is a local variable, which means it exists only during the call to the toString method. The variable is created when toString executes, and it ceases to exist when toString completes.

Now that you know that the new operator returns a reference to the object created, you know what is assigned to fmt: a reference to the DecimalFormat object that new created and ran a constructor on. Not surprisingly, then, fmt is declared as a DecimalFormat object. Except that it's not. It's actually declared as a reference to a DecimalFormat object. If you've seen aliasing in C or Python, where two different variables hold the address of the same object, you can appreciate the difference between an object and a reference to an object.

Having created a DecimalFormat object and assigning its address to the local variable fmt, the toString method then calls the format method on this DecimalFormat object, with myValue as a parameter (the only parameter) to the format method. We don't know how the format method works, but that's abstraction acting in our favor. Of course, we haven't even said what the format method does, but we can worry about that later.

What's important here is how we call a method on an object. We called fmt.format(myValue). Here, fmt is a reference to a DecimalFormat object, format is a method of the DecimalFormat class, and myValue is the parameter to the call. The general form of a method call is

objectReference.methodName(parameters)

Python programmers have seen this syntax before, but C programmers have not.

I like to think of objects as "things" and methods as "actions." Indeed, most of the time, the name of a class should be a noun or a noun phrase. And the name of a method should include a verb. (With the obvious exception for constructors, which are required to have the same name as the class.)

Now, what does the format method return? You can tell from how it's used. The toString method just takes what format returns and immediately returns it to its caller. And we know that toString returns a String or, more precisely, a reference to a String. Therefore, the format method must return a reference to a String.

The last method in the Counter class has the special name main:

  /** 
   * A main program to test the counter.  
   * (Including such testing programs is a good idea.)
   */
  public static void main(String args[]) {
    // Create variables that can reference two Counters.
    Counter c1, c2;

    c1 = new Counter(5);  // wraps at 5
    c2 = new Counter();   // wraps at 12

    final int TIMES = 50;

    System.out.println("c1\tc2\tsum");
    // Show lots of Counter values.
    for (int i = 0; i < TIMES; i++) {
      System.out.println(c1 + "\t" + c2 + "\t" + (c1.getValue() + c2.getValue()));

      // Tick both Counters.
      c1.tick();
      c2.tick();
    }

    c1.reset();
    c2.reset();
    System.out.println("After reset:\t" + c1 + "\t" + c2);
    c1.set(4); 
    c2.set(10);
    System.out.println("After set:\t" + c1 + "\t" + c2);
    c1.set(5); 
    c2.set(-1);
    System.out.println("After invalid:\t" + c1 + "\t" + c2);
  }

The main method is where program execution starts. In Eclipse, we always have to say which class contains the main method in which we want to start executing the program. So we can have lots of main methods in an Eclipse project, but only one will be the main method.

The header of the main method is boilerplate: public static void main(String args[]). As we'll see, a static method is not called on any object. The main method must be static, because it's the first thing executed, and so no objects can possibly have been created at the time main starts executing. The parameter String args[] allows for command-line arguments. The [] part indicates that args is actually an array of references to String. C programmers have seen arrays. So have Python programmers, but they're called "lists" in Python.

What does the main method do? It starts by declaring local variables c1 and c2 as references to Counter objects. Then it creates two Counter objects. The first one has a limit of 5; the new operator calls the one-parameter constructor. The second object has a limit of 12; the new operator calls the parameterless constructor (which is also called a default constructor). Remembering that new returns a reference to the object it creates, we see that c1 is assigned a reference to the Counter whose limit is 5 and c2 is assigned a reference to the Counter whose limit is 12.

Next, main declares a final local variable TIMES with the value 50. Then, main prints some output to the console by calling the method println on a built-in object referenced by System.out. The println method takes a string and prints it on the console. As in C and Python, we can include escaped characters in a string literal; here, \t denotes the tab character.

Then comes a for-loop. The syntax is exactly the same as in C, but this syntax will be new for Python programmers. Java for-loops are quite a bit more general than in Python, and they do not require lists (or arrays) to be involved. A for-loop has the form

for (initial; test; update)
  body

and it is equivalent to a while-loop with the form

initial
while (test) {
  body
  update
}

Therefore, we could have written the for-loop as the equivalent while-loop

  int i = 0;
  while (i < TIMES) {
    System.out.println(c1 + "\t" + c2 + "\t" + (c1.getValue() + c2.getValue()));

    // Tick both Counters.
    c1.tick();
    c2.tick();
    i++;
    }

Although you might find the Python loop header for i in range(TIMES): to be easier, the more general form of Java for-loops has advantages that we'll see later on.

The body of the for-loop calls the tick method on each of the two Counter objects, using the objectReference.methodName(parameters) syntax.

After the for-loop terminates, the main method calls reset on each Counter and then prints the values of the two objects. There's a lot going on in the parameter to println, so let's take a look. The parameter to println must be a String (more precisely a reference to a String). But we're "adding" the string literal "After reset:\t" and the reference c1. To whatever that addition gives back, we're adding the string literal "\t", and then we add the reference c2. What is going on?

Java assumes that if you apply the + operator and one of the operands is a String (again, really a reference to a String…do you see how a string literal's type is really "reference to a String object"?), then the other operand is converted to a String if necessary and concatenated with the String operand. And so we convert the Counter object that c1 references to a String and concatenate that String with the string literal "After reset:\t". Just how is that Counter object converted to a String? By an implicit call to its toString method! In other words, Java will automatically call toString on this Counter object and use the reference to a String that toString returned. We concatenate the two strings, and then we concatenate the string literal "\t" to that result, and then call toString implicitly on the Counter that c2 references, concatenating the string returned by toString what we've built up so far. Then we concatenate another tab character, followed by concatenating an int value that is implicitly converted to a String. That int value is the sum of the values of the two Counter objects, using values returned by calls to getValue on each of the two objects. Notice how the parentheses around that last sum makes it so that last sum is not concatenation, but plain old addition. That ultimate string is what is passed to println and printed on the console. Whew!

A word about the toString method. Remember that it calls the format method of the DecimalFormat class on an object that was initialized with a string of 00. The format method in this situation will take its parameter (the myValue instance variable of a Counter) and return its string representation, but padded with leading zeros if necessary. For example, if myValue is 7, then format returns 07, but if myValue is 107 then format returns 107.

From here on, the main method is easy. It sets the value of the Counter referenced by c1 to 4 and the value of the Counter referenced by c2 to 10, and then it prints out the values again. Then, main sets the value of the Counter referenced by c1 to 5, and it attempts to set the value of the Counter referenced by c2 to $-$1. But $-$1 is not a legal value for any counter, and so the value 0 will be used instead. Finally, main prints the new values of the two Counter objects.

Abstraction

I said that abstraction is an important concept. How does it play into this example? Because all the instance variables of a Counter object are private, no code from outside the Counter class can access them. The only way to interact with a Counter is by calling its methods. The caller knows what the methods do, but not how it does them. Granted, the implementations of the tick, set, reset, and getValue methods are pretty obvious, but the toString method could have been implemented in several different ways. The caller cares not. As long as the methods do what they're supposed to do, the caller should be happy.

Java types

One of the biggest changes for Python programmers in moving to Java is that you have to declare your variables and say what type each will hold. It isn't that Python didn't have types. It was that Python checked them at run time. Java checks them statically at compile time rather than at run time. By saving all of those run time-checks, Java code is able to run significantly faster than Python code.

Let's remember what a type is and why we have them. At the basic level, computer memory is a long sequence of 1's and 0's, each called a bit (BInary digiT). Memory is broken into eight-bit chunks, called bytes, each with its own address. There are may things that you might want to store in a computer: numbers, characters, colors, sounds, wildebeest objects, etc. Even computer instructions are stored in memory. Each "type" of thing has its own encoding as bits.

When programming in machine language the programmer has to remember what each byte is supposed to represent. If he or she starts treating computer instructions as if they were integers, or integers as if they were computer instructions, bad things happen. (That is what many computer viruses do. They store a bit pattern as data, and then trick the program into running that pattern as code.)

The two things that a type tells us are

Smalltalk, an early OO languge, has a very elegant solution to the type problem. Everything is an object, and the operations that are valid on the object are precisely those defined by its methods. The methods understand how to interpret the bit patterns. It is elegant, but having to ask a number to add itself to another number via a method call is a lot slower than using the hardware "add" instruction. As a result, Smalltalk is s-l-o-w.

Java compromises. Most things are objects whose types are defined by the methods that they implement and the data that they store. The object data is stored somewhere in memory, and variables hold references to the object that tell how to find it. The variables c1 and c2 in the Counter class are examples. In practice the reference is a memory address, but Java treats the reference abstractly and uses it to communicate with the object. (Unlike C and C++, Java has no way to manipulate the memory addresses.) All references in Java are the same size, no matter how many instance variables and methods the object has.

For speed's sake, Java has eight primitive types that are not objects:

Values of a primitive type are actually stored in the variable itself, and so these primitives have different lengths in memory. Therefore, Java has two kinds of variables. If a variable is of a primitive type, the variable contains the actual data itself (the bit pattern representing the data). If a variable is of type reference to an object, then it contains a reference, and the data itself is stored elsewhere.

Why is this distinction important? My wife and I have a joint checking account. We each have an ATM card. The cards are different and have different names on them, but the refer to the same checking account. If I withdraw money with my ATM card, there is less money in the account, and if my wife then looks at the balance it will be smaller even though she did nothing with her ATM card.

In this analogy, the account is the object (and bank account objects are a common example in textbooks). The ATM cards are the variables, each holding a reference to the same account. Any changes made by either of us to the account via our ATM card are seen by both. On the other hand, if my wife has her ATM card re-programmed so that it refers to her personal account (changes the reference stored in the variable), that won't affect my card or the account. She just will no longer be able to use that ATM card to withdraw money from our joint account, because it no longer refers to our joint account.

Some tricky details

Java classes

As I said before, think of a class like a blueprint, and of an object like a house. Defining a class does not create an object of that class, just as drawing a blueprint does not cause a house to be built. A blueprint says that when we build a house, here's what it will be like. And a class says that when we create an object, here are the instance variables and methods it will have.

Although Java does not explicitly require us to, we observe various conventions for capitalization styles of various types of identifiers:

Kinds of variables

Java has three distinct kinds of variables:

Any variable declared within a method is a local variable. Parameters are always local variables for their methods.

If a variable is declared outside a method, then it's either an instance variable (if the declaration does not include static) or a class variable (if the declaration includes static).

Public and private variables and methods

When you declare an instance variable, static variable, or method, you should declare it as either public or private.

If a variable is public, then it can be read or written from anywhere in the program. If a variable is private, then only methods in its class can read or write it. Most of the time, instance and class variables should be private. That way, only the methods in the class can see them. That's important from the point of view of abstraction: code from outside the class should interact with objects in the class only through the methods.

If a method is public, then it can be called from anywhere in the program. If a method is private, then only methods in its class can call it. Most of the time, methods are public. Private methods can be useful, however, especially as "helper" methods within a class that code from outside the class need not know about.

Later in the course, we'll see another way to declare variables and methods: protected.

Calling a method

Just as in C and Python, when you call a method, parameters get their values via call by value. Some terminology:

In call by value, the value of each actual parameter is copied into the corresponding formal parameter. Actual parameters match up with formal parameters one by one, left to right. A formal parameters must be a single variable. An actual parameter can be any expression of the correct type.

How an object references itself

Suppose that an object needs a reference to itself. Java supplies the keyword this for just such a purpose. In Python, self accomplishes the same purpose. (Note that whereas Python requires the first parameter of a method to be self, you don't make a parameter for this in Java.)

Here's one simple reason you'd want to use this. Suppose that we wrote our Counter class as follows:

public class Counter {
  private int limit;    // upper limit on the counter
  private int value;    // current value
  ...

  public Counter(int limit) {
    // How to assign the parameter limit to the instance variable limit?
  }

  ...
}

So how could we assign the parameter limit to the instance variable limit? We can't say limit = limit; because that would just assign a variable's value to the same variable. The problem here is that we have an instance variable and a local variable (the formal parameter) with the same name. Java's rule is that when such a conflict occurs, the local variable wins. So the line limit = limit; assigns the value of the formal parameter limit to the formal parameter limit.

But we can use this to say that we mean the instance variable:

  public Counter(int limit) {
    this.limit = limit;
  }

When we write this.limit, we're saying "the instance variable limit in the object that the constructor is running on." Similarly, we could write the set method as

  public void set(int value) {
    if (value >= 0 && value < limit)
        this.value = value;
    else
        this.value = 0;
  }

The tests use the formal parameter, and the assignment is to the instance variable of the object that set is called on.

Now, you might wonder whether we really need this. After all, if we had the sequence

c = Counter();
c.set(4);

couldn't we just refer to c in the set method? No way! First, c is probably local to some other piece of code, and it's not known within the set method. Second, what if we had two Counter objects:

c1 = Counter();
c2 = Counter();
c1.set(4);
c2.set(7);

Now how do you know which Counter you want to use in set? Sometimes it's the one that c1 references, and sometimes it's the one that c2 references. The pronoun this always references the object that the method was called on. Problem solved.

Printing to the console

As you've seen, you call System.out.println to print to the console. The String that you supply as a parameter is what's printed. If you don't supply a parameter, then a blank line prints to the console.

If you want to print to the console but not end with a newline, then call System.out.print. For example, if you were printing a prompt and wanted the typed input to appear on the same line as the prompt, you could write

System.out.print("Enter a prime number: ");

Java's increment and decrement operators

C programmers are familiar with the ++ and -- operators for incrementing and decrementing. (It might be hard to see but that's two minus signs in a row, with no space between them.) When you use these operators, they have to apply to variables.

int x = 7;
x++;     // legal; x gets the value 8
7++;     // not legal; 7 is not a variable
int y = 10;
(x+y)++; // not legal; (x+y) is not a variable
y--;      // legal; y gets the value 9

You can use the ++ and -- operators in expressions. If you put the ++ or -- before the variable, then the increment or decrement happens before the variable's value is used in the expression. If you put the ++ or -- after the variable, then the increment or decrement happens after the variable's value is used in the expression.

int x = 7, y = 10;
int z = ++x * y--;

Here, x is incremented before it's used in the expression, and so x gets the value 8, and the value of x used in the expression is 8. But y is decremented after it's used in the expression, and so although y will get the value 9, the value of y used in the expression is 10. Hence, z gets the value 80.

As you can see, you can make some complicated expressions using the ++ and -- operators. Just because you can doesn't mean you should!