1.
00 Lecture 5
More on Java Data Types,
Control Structures
Introduction to Methods
Reading for next time: Big Java: 7.1-7.5, 7.8
Floating Point Anomalies
• Anomalous floating point values:
– Undefined, such as 0.0/0.0:
• 0.0/0.0 produces result NaN (Not a Number)
• Any operation involving NaN produces NaN as result
• Two NaN values cannot be equal
• Check if number is NaN by using methods:
– Double.isNaN(double d) or Float.isNAN(int i)
– Return boolean which is true if argument is NaN
– Overflow, such as 1.0/0.0:
• 1.0/0.0 produces result POSITIVE_INFINITY
• -1.0/0.0 produces result NEGATIVE_INFINITY
• Same rules, results as for NaN (Double.isInfinite)
– Underflow, when result is smaller than smallest
possible number we can represent
• Complex, not handled very well (represented as zero)
1
Example
public class NaNTest {
public static void main(String[] args) {
double a=0.0, b=0.0, c, d;
c= a/b;
System.out.println("c: " + c);
if (Double.isNaN(c))
System.out.println(" c is NaN");
d= c + 1.0;
System.out.println("d: " + d);
if (Double.isNaN(d))
System.out.println(" d is NaN");
if (c == d)
System.out.println("Oops");
else
System.out.println("NaN != NaN");
double e= 1.0, f;
f= e/a;
System.out.println("f: " + f);
if (Double.isInfinite(f))
System.out.println(" f is infinite");
}
}
Doubles as Bad Loop Counters
public class Counter {
public static void main(String[] args) {
int i= 0;
double x= 0.0;
while (x <= 10.0) {
x += 0.2;
i++;
if ( i % 10 == 0 || i >= 48)
System.out.println(“x: " + x + " i: " + i);
}
}
}
2
Doubles as Bad Loop Counters
i : 10 x : 1.9999999999999998
i : 20 x : 4.000000000000001
Notice accumulating,
i : 30 x : 6.000000000000003
increasing error. Never
i : 40 x : 8.000000000000004
use floats or doubles as
i : 48 x : 9.599999999999998
loop counters (well,
i : 49 x : 9.799999999999997
almost never…)
i : 50 x : 9.999999999999996
i : 51 x : 10.199999999999996
We went one iteration too many
Exercise
• Create a class AngleTest
– Loop over angles from θmin to θmax by δ
– Output the angle
– Compute and output 1/(θmax - θ)
– Make sure you get very close to θmax
– Input θmin = 0.1, θmax = 4.0, θ = 0.1
• How close do you get?
• Does Java catch the zero divide?
• If you have time:
– Implement this with an int loop counter
3
Numerical Problems
Problem Integer Float, double
Zero divide POSITIVE_INFINITY, POSITIVE_INFINITY,
NEGATIVE_INFINITY NEGATIVE_INFINITY
0/0 NaN (not a number) NaN (not a number)
Overflow No warning. Program POSITIVE_INFINITY,
gives wrong results. NEGATIVE_INFINITY
Underflow Not possible No warning, set to 0
Rounding, Not possible No warning. Program
accumulation errors gives wrong results.
Common, “bad news” cases
More on Control Structures
• Three control structures in Java, or any
language, for that matter:
– Sequence: execute next statement
• This is default behavior
– Branching: if, else statements
• If, else are the primary construct used
• Switch statement used if many choices
– Iteration: while, do, for loops
• Additional constructs exist to terminate loops
‘prematurely’
4
Switch statement
• Used as substitute for long if-else chains
– Branch condition must be integer, can’t be String, float, etc.
– No ranges, just single values or expressions in switch
• C# allows strings as branch condition, but not Java or C++
int speed;
switch (speed/10) { // Limit= 9 mph (bicycle)
case 3: // Drop through to case 2
case 2:
System.out.println(“Arrest”);
case 1: // Drop through to case 1
System.out.println(“Ticket”);
break; // Prevent dropping through
case 0:
System.out.println(“Speed legal”);
break;
default:
System.out.println(“Invalid radar reading”);
}
Switch statement
• Used as substitute for long if-else chains
– Branch condition must be integer, can’t be String, float, etc.
– No ranges, just single values or expressions in switch
• C# allows strings as branch condition, but not Java or C++
int speed;
switch (speed/10) { // Limit= 9 mph (bicycle)
case 3: // Drop through to case 2
case 2:
System.out.println(“Arrest”);
case 1: // Drop through to case 1
System.out.println(“Ticket”);
break; // Prevent dropping through
case 0:
System.out.println(“Speed legal”);
break;
default:
System.out.println(“Invalid radar reading”);
}
5
Terminating Iteration: Break
• Break statement in for, while or do-while
loops transfers control to statement
immediately after end of loop
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
System.out.println(“i: “+i);
if (i*i > 20)
break; // End loop
}
System.out.println("Done");
}
// If break in inner, nested loop, control is
// transferred to the outer loop
Terminating Iteration: Continue
• Continue statement jumps to end of loop but
continues looping
public static void main(String[] args) {
for (int i = 0; i < 7; i++) {
System.out.println(“i: “+i);
if (i*i < 17)
continue; // Skip rest of loop
System.out.println(“i: “+i);
}
System.out.println("Done");
}
// If continue in inner, nested loop, control stays
// in inner loop
6
Control exercise
• Write a class LoopExercise:
– Main() method has:
• Loop over int i going from 0 to 8
– Make j = i2-1
– If j negative, skip the rest of the loop
– Find s= square root of j
– If s > 4, end the loop
– Output i, j and s to see what’s happening
• Print “Done” at the end of the program
Java Methods
• Methods are discrete units of behavior
– You’ve already used some:
• JOptionPane()
• Math.sqrt()
• System.out.println()
– You’ll write your own for the rest of the term, as part of
classes
– Right now, you are writing classes but they only have a
main() method and they create no objects
– We’ll write additional methods in our classes
– (And then create objects that have methods)
– For now, our methods will have the keywords public
static in them
• Treat them as an incantation for this and the next lecture
7
Why Use Methods
– Methods provide a way to invoke the same operation
from many places in your program, avoiding code
repetition
– Methods hide implementation details from the user of
the method
– Variables defined within a method are not visible to
users of the method; they have local scope within the
method. (More on scope next time)
– The method cannot see variables in the program
component (e.g., main()) that calls it either. There is
logical separation between the two, which avoids
variable name conflicts.
– Methods (and objects) allow programs to scale
Method example
public class MethodExample {
public static void main(String[] args) {
double boxWeight= 50;
double boxCube= 10;
String boxID= “Box A”;
double density= getDensity(boxWeight, boxCube);
System.out.println("Density: "+ density);
printBox(boxWeight, boxCube);
}
public static double getDensity(double bw, double bc) {
double result= bw/bc; // 'result' could be 'density'
return result;
}
public static void printBox(double w, double c) {
System.out.println("Box weight: "+w+" cube: "+c);
System.out.println(" Density: "+getDensity(w,c));
// System.out.println(“ ID: “+boxID); // No access to ID
} // Won’t compile!
}
8
Passing Arguments
main(…){
double boxWeight= 50;
Communi-
double boxCube=10;
cation only
String boxID= “Box A”;
via arg list,
double density=getDensity
return value
(boxWeight, boxCube);
… Arguments
matched by
Return value Argument 1 Argument 2 position
double getDensity(double bw, double bc)
{ // Method makes its own copy Assume
// of arguments bw and bc method is
Double result= bw/bc; written first:
return result;} can’t know
main() vars
Method exercise
• Write a class MethodExercise
– Main() method:
• Declares String name, int age, double height
• Sets variables to your name, age, height
• Calls isOldEnough() method
• Calls printInfo() method
– Method isOldEnough() returns true if age >=
21, false otherwise
– Method printInfo prints name, age, height
– Choose appropriate arguments, return values
9
Homework 2
Cable
ymin
Pole Pole
(0,0) x
T wx T
y= cosh + y min −
w T w
cosh( x) = 0.5(e x + e − x )
Solve for T using bisection: find T s.t. f(T)= 0
Then, calculate y for each x and print them out
Bisection
x1 m x2
f(x)= x2 - 2
-8 -6 -4 -2 0 2 4 6 8
f(x1)*f(m) > 0, so no root in [x1, m]
f(m)*f(x2) < 0, so root in [m, x2]. Set x1=m
Assume/analyze only a single root in the interval (e.g., [-4.0, 0.0])
10
Bisection
x1 m x2
f(x)= x2 - 2
-8 -6 -4 -2 0 2 4 6 8
f(m)*f(x2) > 0, so no root in [m, x2]
f(x1)*f(m) < 0, so root in [x1, m]. Set x2= m
Continue until (x2-x1) is small enough
11
