Transcript Chapter 2 Slides

Chapter 2
Elementary Programming
1
Objectives










To write Java programs to perform simple calculations
To obtain input from the console using the Scanner class
To use identifiers to name variables, constants, methods, and
classes
To use variables to store data
To program with assignment statements and assignment
expressions
To use constants to store permanent data
To declare Java primitive data types: byte, short, int, long,
float, double, boolean, and char
To use Java operators to write numeric expressions
To cast value of one type to another type
To know common errors in Java
2
Introducing Programming with an Example
Listing 2.1, page 35:
Computing the Area of a Circle
This program computes the area of the circle.
3
Trace a Program Execution
public class ComputeArea {
/** Main method */
public static void main(String[] args) {
double radius;
double area;
allocate memory
for radius
radius
no value
// Assign a radius
radius = 20.0;
// Compute area
area = radius * radius * 3.14159;
// Display results
System.out.println("The area for the circle of radius " +
radius + " is " + area);
}
}
4
Trace a Program Execution
public class ComputeArea {
/** Main method */
public static void main(String[] args) {
double radius;
double area;
// Assign a radius
radius = 20.0;
// Compute area
area = radius * radius * 3.14159;
memory
radius
no value
area
no value
allocate memory
for area
// Display results
System.out.println("The area for the circle of radius " +
radius + " is " + area);
}
}
5
Trace a Program Execution
public class ComputeArea {
/** Main method */
public static void main(String[] args) {
double radius;
double area;
assign 20 to radius
radius
area
20.0
no value
// Assign a radius
radius = 20.0;
// Compute area
area = radius * radius * 3.14159;
// Display results
System.out.println("The area for the circle of radius " +
radius + " is " + area);
}
}
6
Trace a Program Execution
public class ComputeArea {
/** Main method */
public static void main(String[] args) {
double radius;
double area;
memory
radius
area
20.0
1256.636
// Assign a radius
radius = 20.0;
// Compute area
area = radius * radius * 3.14159;
compute area and assign it
to variable area
// Display results
System.out.println("The area for the circle of radius " +
radius + " is " + area);
}
}
7
Trace a Program Execution
public class ComputeArea {
/** Main method */
public static void main(String[] args) {
double radius;
double area;
memory
radius
area
20.0
1256.636
// Assign a radius
radius = 20.0;
// Compute area
area = radius * radius * 3.14159;
print a message to the
console
// Display results
System.out.println("The area for the circle of radius " +
radius + " is " + area);
}
}
8
Reading Input from the Console
1. Create a Scanner object
Scanner input = new Scanner(System.in);
2. Use the methods next(), nextByte(), nextShort(),
nextInt(), nextLong(), nextFloat(), nextDouble(), or
nextBoolean() to obtain to a string, byte, short, int, long,
float, double, or boolean value.
For example,
Scanner input = new Scanner(System.in);
System.out.print("Enter a double value: ");
double doubleValue = input.nextDouble();
9
Example 1
// Scanner is stored in java.util package
import java.util.Scanner;
public class ComputeAreaWithCnsoleInput
{
public static void main(String[] args)
{
//create a Scanner object
Scanner input = new Scanner(System.in);
//Prompt the user to enter a radius
System.out.print("Enter a number for radius (double): ");
double radius = input.nextDouble();
//Compute area
double area = radius * radius * 3.14159;
//Display results
System.out.println("The area for the circle of radius "
+ radius + " is " + area);
}
}
10
Example 2
// Scanner is stored in java.util package
import java.util.Scanner;
public class ComputeAverage
{
public static void main(String[] args)
{
// create a Scanner object
Scanner input = new Scanner(System.in);
// Prompt the user to enter three numbers
System.out.print("Enter three numbers (type double): ");
double number1 = input.nextDouble();
double number2 = input.nextDouble();
double number3 = input.nextDouble();
// Compute average
double average = (number1 + number2 + number3) / 3.0;
}
// Display results
System.out.println("The average of " + number1 + " " +
number2 + " " + number3 + " is " + average);
}
11
Identifiers
Identifier is a name for an element in the program, such
as variable, class, and method.
 An identifier is a sequence of characters that consist of
letters, digits, underscores (_), and dollar signs ($).
 An identifier must start with a letter, an underscore (_),
or a dollar sign ($). It cannot start with a digit.
 An identifier cannot be a reserved word. (Java
Keywords).
 An identifier can be of any length.

12
Reserved Words
Java reserved words:
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
false
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while
13
Variable Declaration
A variable is a name for a location in memory to store
data of specific type.
A variable must be declared by specifying the variable's
name and the type of information that it will hold
data type
variable name
int total;
int count, temp, result;
Multiple variables can be created in one declaration
14
Variable Initialization
A variable can be given an initial value in the
declaration.
// declare and initialize
int sum;
sum = 0;
int base = 32;
double max = 149.75;
When a variable is referenced in a program, its
current value is used.
15
Examples
// Compute the area
double radius; // declaration
double area;
// declaration
radius = 1.0; // initialization
area = radius * radius * 3.14159;
System.out.println("The area is “ + area + " for radius
"+radius);
// Compute the area
double radius = 2.0;// declaration and initialization
double area = radius * radius * 3.14159; //same here
System.out.println("The area is “ + area + " for radius
"+radius);
16
More Variables
Must declare all variables to let the program know
what to store in the variables.
int grade;
// Declare grade as integer variable
double radius; // Declare radius as double variable
float speed;
// Declare speed as float variable
char letter;
// Declare letter as character variable
boolean flag;
// Declare flag as boolean variable
short price;
// Declare price as short variable
long quantity; // Declare quantity as long variable
17
Variable Initialization Example
// Prints the number of keys on a piano.
public class PianoKeys
{
public static void main (String[] args)
{
int keys = 88; //declare and initialize
System.out.println ("A piano has " + keys + " keys.");
}
}
Output: A piano has 88 keys.
18
Declaring and Initializing in One Step
int x = 1;
double d = 1.4;
Same as:
int x;
x = 1;
double d;
d = 1.4;
19
Assignment
An assignment statement changes the value of a variable
The assignment operator is the = sign
int total;
total = 55;
The expression on the right is evaluated and its result is stored in
the variable on the left.
The value that was in total is overwritten.
You can only assign a value to a variable that is consistent with
the variable's declared type.
See program Geometry.java next slide.
20
Assignment - Example
// Print the number of sides of several geometric shapes.
public class Geometry {
public static void main (String[] args) {
int sides = 7; // declare and initialize
System.out.println ("A heptagon has " + sides + " sides.");
sides = 10; // assignment statement
System.out.println ("A decagon has " + sides + " sides.");
sides = 12; // assignment statement
System.out.println ("A dodecagon has " + sides + " sides.");
}
}
21
Assignment Statement Examples
classSize = 40;
// Assign 40 to classSize
radius = 3.0;
// Assign 3.0 to radius
letter = 'A';
// Assign 'A' to letter
answer = true;
// Assign true to answer
//compute and assign to circuleArea
circleArea = radius * radius * Math.PI;
22
Constants
A constant is an identifier that is similar to a variable
except that it holds the same value during its entire
existence
As the name implies, it is constant, not variable.
The compiler will issue an error if you try to change the
value of a constant.
In Java, we use the final modifier to declare a constant,
such as:
final int MIN_HEIGHT = 69;
final boolean DEFAULT_ANSWER = true;
23
Constants
Constants are useful for three important reasons:
- First, they give meaning to otherwise unclear literal
(numeric) values.
- Second, they facilitate program maintenance so you
make the value change in one place.
- Third, they help avoid inadvertent errors by other
programmers.
24
Constants - Examples
Format:
final datatype CONSTANT_NAME = Value;
Examples:
final int CLASS_SIZE = 40;
final double MATH_PI = 3.14159;
final char FAIL_GRADE = 'F';
final boolean FLAG = true;
25
Primitive Data Types
There are eight primitive data types in Java:
Four of them represent integer numbers:
– byte, short, int, long
Two of them represent floating point numbers:
– float, double
One of them represents characters:
– char
And one of them represents boolean values:
– boolean
Everything else in Java is of type object.
26
Sizes of Primitive Numeric Types
byte
8 bits
short
8 bits
8 bits
int
8 bits
8 bits
8 bits
8 bits
long
8 bits
8 bits
8 bits
8 bits
float
8 bits
8 bits
8 bits
8 bits
double
8 bits
8 bits
8 bits
char
8 bits
8 bits
8 bits
8 bits
8 bits
8 bits
8 bits
8 bits
8 bits
8 bits
8 bits
boolean
8 bits
8 bits
8 bits
8 bits
27
Values of Primitive Numeric Types
The difference between the various numeric primitive
types is their memory size:
Type
Storage
Min Value
Max Value
byte
short
int
long
8 bits
16 bits
32 bits
64 bits
-128
-32,768
-2,147,483,648
< -9 x 1018
127
32,767
2,147,483,647
> 9 x 1018
float
Double
32 bits
64 bits
+/- 3.4 x 1038 with 7 significant digits
+/- 1.7 x 10308 with 15 significant digits
boolean 32 bits
Either true or false
28
Numeric Operators
Stop and Record…
29
Numeric Operators
Name
Meaning
Example
Result
+
Addition
34 + 1
35
-
Subtraction
34.0 – 0.1
33.9
*
Multiplication
300 * 30
9000
/
Division
1.0 / 2.0
0.5
%
Remainder
20 % 3
2
30
Integer Division and Remainder
5 / 2
yields an integer 2
5.0 / 2
yields a double value 2.5
5 % 2
yields 1 (remainder value)
Note
5 / 2.0
OR
5.0 / 2
==> 2.5
31
Remainder Operator - Example
Remainder is very useful in programming. For example, an
even number % 2 is always 0 and an odd number % 2 is always
1. So you can use this property to determine whether a number
is even or odd.
Suppose today is Saturday. You and your friends are going
to meet in 10 days from today. What day is would that be?
You can find that out using the following expression:
Saturday is the 6th day in a week
A week has 7 days
(6 + 10) % 7 is 2
The 2nd day in a week is Tuesday
After 10 days
32
Number Literals
A literal is a constant value that appears directly in the
program. For example, 40, 1000000, 5.0, true,
and A are literals in the following statements:
int classSize = 40;
long largeNumber = 1000000;
double increment = 5.0;
boolean defaultAnswer = true;
char letterGrade = 'A';
33
Arithmetic Expressions
3  4 x 10( y  5)( a  b  c)
4 9 x

 9( 
)
5
x
x
y
is translated to
(3+4*x)/5 – 10*(y-5)*(a+b+c)/x + 9*(4/x + (9+x)/y)
34
How to Evaluate an Expression
Java uses arithmetic precedence rule for evaluating
expression.
3 + 4 * 4 + 5 * (4 + 3) - 1
3 + 4 * 4 + 5 * 7 – 1
3 + 16 + 5 * 7 – 1
(1) inside parentheses first
(2) multiplication
(3) multiplication
3 + 16 + 35 – 1
19 + 35 – 1
54 - 1
53
(4) addition
(5) addition
(6) subtraction
35
How to Evaluate an Expression
What is the order of evaluation in the following
expressions?
a + b + c + d + e
1
2
3
4
a + b * c - d / e
3
1
4
2
a / (b + c) - d % e
2
1
4
3
a / (b * (c + (d - e)))
4
3
2
1
36
Problem: Converting Temperatures
Write a program that converts a Fahrenheit degree to
Celsius using the formula:
celsius  ( 95 )( fahrenheit  32)
Double celsius = (5.0/9.0) * (fahrenheit - 32);
Homework: Type, compile and execute the program in
listing 6, page 51.
37
Problem: Displaying Current Time
Write a program that displays current time in GMT in the
format hour:minute:second such as 1:45:19.
The currentTimeMillis method in the System class returns
the current time in milliseconds since the midnight, January
1, 1970 GMT. (1970 was the year when the Unix operating
system was formally introduced.) You can use this method
to obtain the current time, and then compute the current
second, minute, and hour as follows.
Homework: Type, compile and execute the program in
listing 7, page 52. Notice the use of the division(/) and
remainder (%) operators.
38
Shortcut Assignment Operators
Operator
Example
Equivalent (recommended use)
+=
i += 8
i = i + 8
-=
f -= 8.0
f = f - 8.0
*=
i *= 8
i = i * 8
/=
i /= 8
i = i / 8
%=
i %= 8
i = i % 8
39
Increment and
Decrement Operators
Operator
Name
++var
preincrement
Description
The expression (++var) increments var by 1 and evaluates
to the new value in var after the increment.
var++
postincrement
The expression (var++) evaluates to the original value
in var and increments var by 1.
--var
predecrement
The expression (--var) decrements var by 1 and evaluates
to the new value in var after the decrement.
var--
postdecrement The expression (var--) evaluates to the original value
in var and decrements var by 1.
40
Increment and
Decrement Operators, cont.
int i = 10;
int newNum = 10 * i++;
Same effect as
int i = 10;
int newNum = 10 * (++i);
Same effect as
int newNum = 10 * i;
i = i + 1;
i = i + 1;
int newNum = 10 * i;
41
Increment and
Decrement Operators, cont.
Using increment and decrement operators makes expressions
short, but it also makes them complex and difficult to read.
Avoid using these operators in expressions that modify multiple
variables, or the same variable for multiple times such as this:
int i = 10;
int k = ++i + i;
Output:
i = 11
k = 22
42
Type Conversion
Conversions must be handled carefully to avoid losing
information.
Widening conversions are safest because they tend to go from a
small data type to a larger one (such as short to int)
Narrowing conversions can lose information because they tend
to go from a large data type to a smaller one (such as int to
short)
In Java, data conversions can occur in three ways:
- assignment conversion
- promotion (temporary conversion)
- casting (explicit conversion)
43
Assignment Conversion
Assignment conversion occurs when a value of one type is assigned
to a variable of another
If money is a float variable and dollars is an int variable, the
following assignment converts the value in dollars to a float.
double money = 0.0;
int dollars = 10;
money = dollars; // money has value 10.0
dollars = money; // ERROR!!!!
Only widening conversion can happen via assignment.
Note that the value or type of dollars did not change.
44
Promotion Conversion
Promotion happens automatically (and temporarily) when
operators in expressions convert their operands.
Example :
int count = 5;
double sum = 20.0;
double result;
result = sum/count; //result contains 4.0
result = count/sum; //result contains 0.25
The value of count is temporarily promoted (converted) to a
floating point value to perform the calculation. count is still of
type integer.
45
Casting Conversion
Casting is the most powerful, and dangerous, technique for
conversion.
Both widening and narrowing conversions can be accomplished
by explicitly casting.
To cast, the type name is put in parentheses in front of the value
being converted.
Example
int total = 20, count = 5;
double result1, result2;
. . .
result1 = (float)total/count; //casting and promotion
result2 = (float)(total/count); //casting only
46
Casting Conversion
How do we solve the problem of 3 / 2 having a result of 1.
You can make one of the values floating point by adding .0 to
it (conversion by promotion)
–3.0 / 2
–3 / 2.0
The result type will then be floating point value (1.5)
Or
You can cast one of the values to either float or double
(conversion by casting)
–(double) 3 / 2
–3 / (float) 2
47
Conversion Rules
When performing an operation involving two operands of
different types, Java automatically converts the operand
based on the following rules:
1. If one of the operands is double, the other is
converted into double.
2. Otherwise, if one of the operands is float, the other
is converted into float.
3. Otherwise, if one of the operands is long, the other
is converted into long.
4. Otherwise, both operands are converted into int.
48
Type Casting Examples
Implicit casting
double d = 3; //type widening with assignment
Explicit casting
int i = (int)3.0; //explicit type narrowing
int i = (int)3.9; //fraction part is truncated
What is wrong here? int x = 5 / 2.0; //syntax error
range increases
byte, short, int, long, float, double
49
Software Development Process
50
Software Development Process
In this course, you need to start with:
1. Understand the problem.
2. Identify what the input and outputs.
3. Decide how to process the inputs to produce the
outputs (algorithm).
4. Write down the logical steps of the algorithm.
5. Translate the algorithmic steps into Java code.
6. Type code, compile, fix errors, run, and test the
program for correctness of outputs.
51
Problem: Monetary Units
This program allows the user to enter the amount
representing dollars and cents (in decimal) and output a
report listing the monetary equivalence in coins (dollars,
quarters, dimes, nickels, and pennies). The program
should report maximum number of dollars, then the
maximum number of quarters, and so on, in this order.
52
Problem: Monetary Units
Development steps:
1. Understand the problem: The program reads an amount of money
such as $1.41 and prints out the change.
2. Ask the user to enter an amount (of type double).
3. Convert the amount to pennies (cents) (easier to work with integer
type). Use casting to convert value to int type.
3. Divide the amount by 100 to get # of dollars. Determine the remaining
amount (subtract the dollars from the amount - use remainder
operator %).
4. Repeat step 3 for quarters, dimes, and nickels.
5. The final remaining amount is the number of pennies.
6. Display the outputs with proper labels.
53
Problem: Monetary Units
import java.util.Scanner;
public class ComputeChange {
public static void main(String[] args) {
// Create a Scanner
// Read amount from user
// Find the number of one dollars
int numberOfOneDollars = remainingAmount / 100;
remainingAmount = remainingAmount % 100;
// Find the number of quarters in the remaining amount
int numberOfQuarters = remainingAmount / 25;
remainingAmount = remainingAmount % 25;
// . . .
Other code...
// Display results
System.out.println("Your amount " + amount + " consists of");
System.out.println("
" + numberOfOneDollars + " dollars");
. . .
}
}
// see listing 2.10, page 63 for complete code
54
Common Errors

Common Error 1: Undeclared/Uninitialized Variables and
Unused Variables

Common Error 2: Overflow Errors

Common Error 3: Round-off Errors

Common Error 4: Unintended Integer Division

Common Error 5: Redundant Input Objects (such as
creating a scanner object for each input variable or each
type!)
See textbook, page 66, for examples.
55
End of Chapter 2
56