Objectives

• Use primitive types
• Use expressions
• Use variables and assignment statements
• Use Scanner for keyboard input
• Use for loops
• Introduce pseudocode

Assignments

• Read Chapter 2 and pp. 162-165 (subsection on Interactive Programs and Scanner Objects)
• Lab 1 Due beginning of Week 3
• Quiz 2 Available end of Week 3
• Lab 2 Due beginning of Week 4
• Quiz 3 Available end of Week 4
• Finish Project 1 (Due beginning of Week 5)

Outline

Data Types
Variables
For Loops
Managing Complexity

---

Data types

A data type is a category or set of values that are related.  A data type indicates what operations can be performed on the values.  For example, numbers have different operations from strings.  Java is a strongly typed language, meaning that the compiler requires a data type to be specified for every value.

In Java, a data type is either a primitive type or a class.  Classes will be discussed later. 

Java has eight primitive types.  We will focus on four of them.


How does Java distinguish between an int and a double?  A double has a decimal point, while an int does not, so 3.0 and 3 belong to different data types.

Expressions

An expression is a value or combination of operations that computes a value.  The simplest expression is a single value, which is also called a literal.  A complex expression can use operators and parentheses.  For example, 42 is a literal, and 1 + 4 * 5 and (7 + 2) * 6 / 3 are complex expressions.

An operator combines multiple values or expressions.  There are five arithmetic operators for combining two ints or two doubles.

As a program runs, its expressions are evaluated.  We can use System.out.println to see the result.

Integer Division and Remainder

When we divide ints, the result is also an int.  For example,  32 / 5  is  6,  -84 / 10  is  -8,  and  156 / 100  is  1.  Dividing by 0 causes an error when your program runs.

The % operator computes the remainder from integer division.  For example,  32 % 5  is  2,  -84 % 10  is  -4,  and  156 % 100  is  56. 

At first, integer division and remainder may seem odd to you, but they have many applications.

• Obtain the last digit of a number:  1234 % 10  is  4.
• Obtain the last 2 digits of a number:  1234 % 100  is  34.
• Obtain the number without the last 2 digits:  1234 / 100  is  12.
• See whether a number is odd:  6 % 2  is  0,  7 % 2  is  1.

Precedence

Precedence is the order in which operators are evaluated.  Generally operators in an expression are evaluated from left to right.

However, the "multiplicative" operators *, /, and % have a higher level of precedence than the "additive" operators + and -.

Also, it is possible to use + and - as "unary" operators, for example, -3 and +2.  Unary operators have a higher level of precedence than the multiplicative and additive operators.

Parentheses can force a certain order of evaluation, but spacing has no effect.

Mixing types

When ints and doubles are mixed, the result is a double.  For example,  4.2 * 3  is  12.6.  However, the conversion is per-operator, so strange things can happen if integer division is involved.  For example,  7 / 3 * 1.2 + 3 / 2  is  3.4,  not  4.3.

Sometimes, we want to convert between ints and doubles.  Maybe we want to avoid integer division, or maybe we want to obtain the integer part of a double (called truncation).  A cast can be used to force a conversion.  For example,  (int) 7.7  is  7,  and  (double) 7  is  7.0.

String Concatenation

String concatenation is combining two or more strings into a longer string.  The + operator is used for concatenation.  If a string is concatenated with another type of value, the value is first converted to a string.  For example:


Seemingly strange results can occur because of precedence.  Java will try to evaluate an expression with + and - from left to right, but *, /, and % still have a higher level of precedence.
String concatenation can be used with System.out.println to print strings and arithmetic expressions together on one line.  Remember to add spaces as needed.  For example:

---

Variables

A variable is a location of the computer's memory that is given a name and type, and can store a value.  To use a variable in Java, you must first declare and initialize the variable.  Then, every statement afterwards that is within the scope of the variable can use the value of the variable or store a different value in the variable.

Consider the following program for computing the body mass index.

Declarations

The program declares three variables.  Their names are height, weight, and bmi.  Their type is double, meaning that they can store double values.  After they are declared, the computer gives each variable a location, but they have no value.


In general, a variable declaration allocates memory for a new variable with a given name and type.  A declaration can be made with the syntax:

For example, here is how to declare the names lucy, linus, and snoopy as the types int, char, and boolean, respectively.

Note: In this class we will not put more than one declaration on a line.

Assignments

The next three statements in the BMI1 program are assignment statements, which are used to store values in the variables.  First, 70.0 is stored in height.

Next, 195.0 is stored in weight.


Finally, weight / (height * height) * 703.0 is evaluated using the current values of weight and height, and that value is stored in bmi (note that the value for bmi is not exact even though there are 17 digits; more about this in later weeks).


In general, an assignment first evaluates the expression to the right of the = sign and then stores the value into the variable on the left.  An assignment can be made with the syntax:

Using Variables

We already used height and weight for assigning a value to bmi.  The last three statements of the BMI1 program report the values of these variables and produce the following output:

Adjusting the Value of a Variable

Often, we want to modify the value of a variable by incrementing (adding one to) or decrementing (subtracting one from) its value, or: add, subtract, multiply, or divide a variable by a certain amount.

Java has shortcuts that are equivalent to the above statements.

---

Using Scanner to Input Values from the Keyboard

In the BMI1 program, we need to modify the program to to compute the body mass index for different heights and weights.
A better solution is to allow the user to input values.
The BMI2 program shows how this can be done.


The important new elements in this program are:

• The import statement tells Java we want to use its java.util package.  The Scanner class is part of this package.
  
  
• The statement:

  public static final Scanner CONSOLE = new Scanner(System.in);
  

  declares a special kind of variable named CONSOLE of type Scanner, creates a Scanner "object" for keyboard input, and stores the object in the variable.  This kind of variable is called a class constant.  It can be used anywhere in the class, except that its value cannot be changed.  The name is all uppercase because that is the convention for constants.  Class constants are discussed in more detail later in these notes.
  
  
• The statement:

  System.out.println("Enter height:");
  

  prompts the user for information.
  
  
• The statement:

  height = CONSOLE.nextDouble();
  

  inputs a number from the keyboard and stores the number in the variable height.

The combination of a prompt before an input should be used whenever you want the user to enter a value. If you want to read an int instead of a double, replace CONSOLE.nextDouble() with CONSOLE.nextInt().

---

For Loops

The following program prints the squares of the first six integers.

This is repetitious.  We can make it so that all of the print statements are identical by using a variable.
This is repetitious.  What we would like is have some way of writing the print statement once, and telling the computer not only to repeat it six times, but also how to vary the value of the variable appropriately each time.  The for loop allows us to do this.

This program declares a variable named count with type int.  The "for" line tells Java to initialize count to 1, to keep repeating as long as count is less than or equal to 6, and to increment count after each iteration (a repetition of the loop).  The { at the end of the line and its corresponding } three lines below indicate what statements are in the body of the loop, that is, what statements are to be repeated.  The print statement uses the count variable to vary what is printed out in an appropriate way.  For obvious reasons, count is the control variable of the for loop.

In general, the syntax of the for loop is:


A for loop is executed in the following manner:

System.out.print

Suppose we want to print the squares on one line as follows:
To do this, we need to print one number at a time without a newline.  This can be done using System.out.print, for example:
Unfortunately, the above program does not print spaces between the numbers, but you should be able to fix this either by another System.out.print or by concatenation.  Note that if we want to just print a newline without any other characters, we can use System.out.println with nothing between the parentheses.

for Loop Variations

For loops are usually used to count from one value to another value, but there are many common variations.

• Declare the control variable (i in this example) in the initialization.

  // prints 1 2 3 4 5 6
  for (int i = 1; i <= 6; i++) {
      System.out.print(i + " ");
  }
  System.out.println();
  

• Another way to perform a certain number of iterations is to start counting at 0 and then go up to but not including the number of iterations.

  // prints $$$$$$$$$$
  for (int j = 0; j < 10; j++) {
      System.out.print("$");
  }
  System.out.println();
  

• To count down, decrement the control variable in the update, and use > or >= in the test.

  // prints 10 9 8 7 6 5 4 3 2 1 Lift off!
  for (int k = 10; k > 0; k--) {
      System.out.print(k + " ");
  }
  System.out.println("Lift off!");
  

Nested Loops

Consider printing the following figure one star at a time:
We could write six for loops with a newline after each loop.  That is, we might have the following plan.
This could be coded in the following way.

This is clearly repetitious.  We should have a variable (let's name it row) that starts at 1 and goes up to 6.
Here is another version which is similar, but shows the pattern more clearly.
The advantage of this code is that there are 4 lines that are exactly duplicated for each line printed.
They only differ in the value of row.

This corresponds to the following plan. Note that we have a loop within a loop.  We want to print a certain number of rows.  To print a row, we want to print a certain number of stars followed by a newline.  Note that the value of row is also the number of stars we want to print.  Our new program is:

---

Managing Complexity

Consider the task of producing the following output, a 12 by 7 box using asterisks for the sides.

Pseudocode

Pseudocode is an English description of an algorithm as a sequence of steps.

Where should "Print a newline." appear in the pseudocode?

Procedural Decomposition

As you might recall, procedural decomposition separates a task into subtasks. We implement each subtask with a static method. "Print 12 asterisks" can be coded as:

public static void printAsterisks( ) {  
  for (int i = 1; i <= 12; i++) {  
    System.out.print("*");
  }
  System.out.println( );
}

The steps within the pseudocode's loop can be coded as:

public static void printAsteriskSpacesAsterisk( ) {  
  System.out.print("*");
  for (int i = 1; i <= 10; i++) {
    System.out.print(" ");
  }
  System.out.print("*");
  System.out.println( );
}

The main method calls these methods as specified by the pseudocode:

public static void main(String[] args) {  
  printAsterisks( );
  for (int i = 1; i <= 5; i++) {
    printAsteriskSpacesAsterisk( );
  }
  printAsterisks( );
}

Scope

The scope of a variable is the part of a program where the variable exists.  A local variable is a variable declared inside a method, which means that variable is accessible only in that method.  In addition, a local variable declared in a for loop is accessible only in that loop.

For example, each method in the above PrintBox program has a variable named i.  Because these variables are local, they are considered separate variables.  Otherwise, the for loop in the main method would only have one iteration because printAsteriskSpacesAsterisk would have changed i to 11.  Scope prevents a method from interfering with the local variables of other methods.

Blocks

A block is a collection of statements, usually starting with an open brace and ending with a closing brace.
For example the main program for printing a box:

1.   public static void main(String[] args) {  
2.     printAsterisks( );
3.     for (int i = 1; i <= 5; i++) {
4.       printAsteriskSpacesAsterisk( );
5.     }
6.     printAsterisks( );
7.  }

contains two blocks, one for the main program consisting of lines 1-7 and one the for loop in lines 3-5.
The scope of a variable declared inside a block, ends at the end of the block

A for statement also starts a block, so the i declared in line 3 has scope consisting of lines 3-5. This variable cannot be accessed outside this block.

When the body of a for contains only one statement, the braces are not needed, so the above main method can also be witten as:

public static void main(String[] args) {  
  printAsterisks( );
  for (int i = 1; i <= 5; i++) 
    printAsteriskSpacesAsterisk( );
  printAsterisks( );
}

Class Constants

A class constant is a variable accessible to the whole class, whose value can only be set when it is declared, and whose value can't be changed while the program is running.

Suppose we want to generalize the PrintBox program so that the dimensions of the box can be easily changed.  Only the main method needs to know the height of the box, but both of the other methods need to know the width of the box to print the right number of asterisks or spaces.  A class constant is declared within the class, but outside of the methods.  Note that the convention for naming constants is all capitals with underscores between words: To use the class constants inside the methods, the magic numbers (5, 12, and 10) need to be replaced with the constants or with variables calculated from the constants.  For example, a statement like the following should appear in the main method: where numberOfLinesWithSpaces should replace 10 in the for loop test.  Likewise, a statement like the following should appear in the AsteriskSpacesAsterisk method: where numberOfSpaces should replace 5 in the for loop test.

---