CSCI A201/A597 Lecture Notes 9 Spring 2000

The practical exam will be on February 24-25. It will be closed-book, and you will have to write a working program during the interval of time that is allotted to the lab.

The program will be based on your assignment 3: Crossed.java. You will be asked to produce a scalable pattern such us the letters L, Z, X, E, F, I, T, M (all uppercase). The steps that you need to take to produce a working solution is to map your pattern on a two-dimensional grid of lines and rows, and use print and println as necessary to print it out.

The exam will be closed book, but an exhaustive range of patterns that you could see on the exam will be announced ahead of time with hints on how to map each pattern on the grid (if a pattern is complicated).

The midterm exam will be on March 2, in class. It will be a multiple-choice test, and to prepare you for it your next assignment (due February 18) wil be a battery of quizzes that you need to work with in QuizSite. The items on the midterm will be very similar to the items in this battery of on-line tests.

I will have another announcement next week, regarding the possibility of offering a special (more advanced) term project in exchange for the final exam. That is, we will make available a term project for those of you that are interested, such that if you complete that project you don't need to come and take the final exam, and the grade for the project will count as the grade for the final. Details forthcoming in a week.

Now we want to review some of the material that we have already covered and in the process add some more.

Primitive Types in Java

1. Whole Numbers (see page 12 in the book)

These are represented by the keywords:

• int
• long
• short
• byte

So where can we make use of the int keyword in a Java program?

We use it to declare the type of a variable such as:

int n;

You can declare more than one variable at a time, for example:

int i, j;

Let's look at some examples:

i = 0; 
int i, j;
j = 3;

A variable can only be declared once in a block.

int i; 
i = 3;
int i; 

int i; 
i = i + 1; 

The bottom line of all this is that you need to initialize your variables as soon as you declare them. You can declare them in one line, as part of the declaration, like this:

int i = 0, j = 3;

int i;
int j = Integer.parseInt(args[0]);

if (j % 2 == 0) { 
  i = 4; 
} 

i = i + 1; 

Even if your user will be careful not to type an odd number it still is possible to call your program with such a number as the first argument on the command line, so the compiler will point this out and signal it as an error.

2. Operations on Whole Numbers

Here's a small table of operators:

Operator(s)	Precedence	Associativity
* / %	6	left to right
+ -	5	left to right
< <= >= >	4	left to right
== !=	3	left to right

So, for example, the following expression

 n < n + 4 

The expression:

7 % 3 * 2 

7 % (3 * 2)

3. Numbers with decimals

These are represented by the keywords:

• float
• double

Our choice of numbers with decimals will be as doubles.

How do you use this keyword?

Same as we use int: we use it to declare variables of this type.

For example:

double x, y;

double pi = 3.141592;

double a, b = 3; 
int n = 6;
a = n + 1; 

To make sure you don't forget that Java wants you to make it explicit that you want to do the conversion. Here's how it looks:

double r = 6.3; 
int n; 
n = (int)r; 

4. Declarations Again

Remember that declarations can appear anywhere in the program, but that variables can be used only after they are declared. Given this it is better to declare all the variables that you plan to use at the top of your program.

Here's however an example in which we do not follow the rule simply to illustrate that from a testing point of view it is OK to declare a variable next to where you want to use it, if you use it in only one place (see the example in the next section).

Declaring variables inside blocks of statements grouped together by curly braces makes them invisible from outside the block. In the block however the variable will be known as soon as it is declared. We have encountered blocks of statements in if statements, while and for loops.

5. Operations on doubles

The operations that we have listed in section 2 above also apply for numbers represented as doubles (that have decimals). Even % is available to compute the portion of the value that is unaccounted for by the whole division (page 19).

Here's the example:

public class T {
    public static void main(String[] args) {
       double a, b = 3.2; // only b is initialized 
       int n = (int)b;    // n is set to 3 and 0.2 is lost 
       a = n + 1;         // a is set to 4.0 
       double q = b % 2;  // q declared and initialized to 1.2 
       System.out.println(a + " " + b + " " + n + " q = " + q); 
    } 
} 

frilled.cs.indiana.edu%javac T.java
frilled.cs.indiana.edu%java T
4.0 3.2 3 q = 1.2000000000000002
frilled.cs.indiana.edu%

6. The Math class

Pages 20-22 of your text describe a few functions that are available in the Math class. As I described in class last time classes, without which there can be no Java program, serve two distinct purposes:

• as collections of useful frequently used methods (and/or data)
• as blueprints (such as ConsoleWindow())

• compute the square root (Math.sqrt)
• compute an arbitrary power (Math.pow)
• compute trigonometric functions (Math.cos)
• round a fractional number to the nearest whole number

7. Truth Values

There are only two truth values in Java: true and false.

These values can be assigned to variables declared as boolean, such as:

boolean done = false;

done = (i > 11);

public class T {
  public static void main(String[] args) {
    int n = 10; 
    boolean double = false; 
    while (! done) {
      System.out.println(i); 
      i = i + 1; 
      if (i > n) {
        done = true; 
      } 
    } 
  } 
} 

Table 1.6 in your book contains then results of applying various boolean operators on two boolean values P and Q. The operators listed are:

Operator(s)	Precedence	Associativity
!	7	left to right
== !=	3	left to right
&&	2	left to right
||	1	left to right

Regarding the definitions of && (logical and) and || (logical or) we can summarize them as follows:

• a && b is true only when a is true AND b is true. If either one of them is false (or both) their conjunction is also false.

• a || b is true when either a is true OR b is true (or they both are true). That essentially means that only when both are false can the result be false

As an example, assume the following boolean expression

  n < 10  &&  n > 3   ||   m < 20  &&  m > 16

Given the order of precedence of the operators and their associativity the expression listed above will evaluate in the following way (where the order of evaluation is not changed, only made explicit by the parentheses).

 (n < 10) && (n > 3)  ||  (m < 20) && (m > 16)

((n < 10) && (n > 3)) || ((m < 20) && (m > 16))

There are additional examples in the book on pages 24-27.

9. Characters

The keyword that describes this primitive type is char.

The characters are listed at the end of the book on page 290 (section 4 of appendix B). They are listed in a certain order and then numbered. This is not just any order, it is the American Standard Code for Information Interchange (ASCII) and so it's used by many people not just us. The ASCII code for uppercase A is going to be 65 everywhere in the world.

To identify character constants we use single quotes:

char grade;
grade = 'A'; 

A few special (unprintable) characters have a special representation in terms of the characters that we normally think as printable. For example the character with ASCII code 10 (newline), that is represented as an escape sequence: '\n' (that is, backslash followed by lowercase n).

A few more are listed in figure 1.5 in your book (page 24) and in appendix B.

Because of this mapping of characters into numbers many things that we can do with (whole) numbers can also be done with characters. Such as:

char grade;
grade = 'A'; 
grade = (char)(grade + 1); 
System.out.println(grade); 

You can however add two characters and obtain a third one.

char r = (char)(' ' + '!'); 
System.out.println(r);

char rank = '0' + 3;

Thank means that the example above which prints B could be simplified as follows:

public class T2 {
    public static void main(String[] args) {
        char grade = 'A' + 1; 
	System.out.println(grade);
    } 
}

Please check this section in the book on pages 22-23.

10. Strings of Characters

Strings are widely used in Java programs ut they are not a primitive type. Strings are objects.

Strings are presented in your book briefly in section 1.4.1 (pages 29-30) and then in one entire chapter 5. The part in chapter 1 covers this:

• the use of the concatenation operator (+)
• String constants
• declaration of String variables and initialization with String constants
• comparing two Strings for equality

Instead the equals method of one of the operands should be used with the other operands as an argument. It will return a truth value that will signifiy whether the two strings ofd characters read the same (capitalization and spaces included).

So we could have a code fragment like this:

String a = "George Boole"; 
String b = "George " + "Boole"; 
boolean test1, test2, test3;
test1 = a.equals(b); 
test2 = b.equals(a); 
test3 = a.equals("George" + " Boole");

Sections 5.1.1 and 5.1.2 present a few more methods that Strings understand. (Invoking a method on an object is as if we'd be sending a message to that object, with some parameters that qualify our message).

Let's summarize them here briefly:

charAt(i)

returns the (i+1)^thcharacter of the string (note that the indexing is again 0-based)

length()

returns the number of characters in the String

substring(i)

returns the portion of the original String that starts with character i (remember that the indexing is 0-based)

substring(i, j)

returns the string of character between positions i and j - 1 inclusively

11. Syntactic Hazards

We conclude by saying that a sequence of zero or more instructions enclosed by a pair of curly braces ({ and }) is a valid Java construct called a block of statements.

The syntax for an if statement (chapter 3, pp. 72-74) can be described like this:

if (<condition>) 
  <statement>

We need to define them or we can't put such an if into valid Java program.

For <condition> think of any expression that you could build using numbers or int variables compared to each other, as well as boolean combinations of these, as seen in the example that was testing whether both m and n where in some range, a few paragraphs above (meant to illustrate the order of evaluations).

For <statement> we can either use

• an assignment statement
• another if
• a while statement
• a for statement
• or a block of statements

int i = 3, j = 2; 
if (i < j) 
  System.out.print(i + "is less");
  System.out.println(" than " + j); 

 than 2

To add them both to the then branch we need to group them in a block:

int i = 3, j = 2; 
if (i < j) { 
  System.out.print(i + "is less");
  System.out.println(" than " + j); 
}