09/01/10
20:56:42 1
04
CS 61B: Lecture 4
Friday, September 3, 2010
Today’s reading: S&B pp. 10-14, 49-53, 75, 78-79, 86, 117, 286-287, 292, 660.
PRIMITIVE TYPES
===============
Not all variables are references to objects. Some variables are primitive
types, which store values like "3", "7.2", "h", and "false". They are:
byte: A 8-bit integer in the range -128...127. (One bit is the sign.)
short: A 16-bit integer in the range -32768...32767.
int: A 32-bit integer in the range -2147483648...2147483647.
long: A 64-bit integer, range -9223372036854775808...9223372036854775807.
double: A 64-bit floating-point number like 18.355625430920409.
float: A 32-bit floating-point number; has fewer digits of precision.
boolean: "true" or "false".
char: A single character.
long values are written with an L on the end: long x = 43L;
This tells the compiler to internally write out "43" in a 64-bit format.
double and float values must have a decimal point: double y = 18.0;
float values are written with an f at the end: float f = 43.9f;
Object types Primitive types
--------------------------------------------------------------------------
Variable contains a reference value
How defined? class definition built into Java
How created? "new" "6", "3.4", "true"
How initialized? constructor default (usually zero)
How used? methods operators ("+", "*", etc.)
Operations on int, long, short, and byte types.
-x x * y
x + y x / y <-- rounds toward zero (drops the remainder).
x - y x % y <-- calculates the remainder of x / y.
Except for "%", these operations are also available for doubles and floats.
Floating-point division ("/") doesn’t round to the nearest integer, but it does
round off after a certain number of bits determined by the storage space.
The java.lang library has more operations in...
- the Math class.
x = Math.abs(y); // Absolute value. Also see Math.sqrt, Math.sin, etc.
- the Integer class.
int x = Integer.parseInt("1984"); // Convert a string to a number.
- the Double class.
double d = Double.parseDouble("3.14");
Converting types: integers can be assigned to variables of longer types.
int i = 43;
long l = 43L;
l = i; // Okay, because longs are a superset of ints.
i = l; // Compiler ERROR.
i = (int) l; // Okay.
The string "(int)" is called a cast, and it casts the long into an int. In the
process, high bits will be lost if l does not fit in the range -2147483648...
2147483647. Java won’t let you compile "i = l" because it’s trying to protect
you from accidentally creating a nonsense value and a hard-to-find bug. Java
requires you to explicitly cast longs to ints to show your acknowledgment that
you may be destroying information.
Similarly, "float f = 5.5f; double d = f;" is fine, but you need an explicit
cast for "double d = 5.5; float f = (float) d;". Integers (even longs) can be
directly assigned to floating-point variables (even floats) without a cast, but
the reverse requires a cast because the number is truncated to an integer.
Boolean Values
--------------
A boolean value is either "true" or "false". Booleans have operations of their
own, signified "&&" (and), "||" (or), and "!" (not).
a | b || a && b | a || b | !a
==================||==============================
false | false || false | false | true
false | true || false | true |
true | false || false | true | false
true | true || true | true |
Boolean values can be specified directly ("true", "false") or be created by
the comparison operators "==", "<", ">", "<=", ">=", "!=" (not equal to).
boolean x = 3 == 5; // x is now false.
x = 4.5 >= 4.5; // x is now true.
x = 4 != 5 - 1; // x is now false.
x = false == (3 == 0); // x is now true.
CONDITIONALS
============
An "if" statement uses a boolean expression to decide whether to execute a set
of statements. The form is
if (boolValue) {
statements;
}
The statements are executed if and only if "boolValue" is "true". The
parentheses around the boolean expression are required (for no good reason).
boolean pass = score >= 75;
if (pass) {
output("You pass CS 61B");
} else {
// The following line executes if and only if score < 75.
output("You are such an unbelievable loser");
}
if-then-else clauses can be (1) nested and (2) daisy-chained. Nesting allows
you to build decision trees. Daisy-chaining allows you to present more than
two alternatives. For instance, suppose you want to find the maximum of three
numbers.
if (x > y) {
if (x > z) {
maximum = x;
} else {
maximum = z;
}
} else if (y > z) {
maximum = y;
} else {
maximum = z;
}
