Transcript Numbers
Numbers
26-Jul-16
Bits and bytes
A bit is a single two-valued quantity: yes or no, true or
false, on or off, high or low, good or bad
One bit can distinguish between two cases: T, F
Two bits can distinguish between four cases: TT, TF,
FT, FF
Three bits can distinguish between eight cases: TTT,
TTF, TFT, TFF, FTT, FTF, FFT, FFF
In general, n bits can distinguish between 2n cases
A byte is 8 bits, therefore 28 = 256 cases
Number systems
The binary (base 2) number system uses two “binary
digits, ” (abbreviation: bits) -- 0 and 1
The octal (base 8) number system uses eight digits:
0, 1, 2, 3, 4, 5, 6, 7
The decimal (base 10) number system uses ten digits:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
The hexadecimal, or “hex” (base 16) number system
uses sixteen digits:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
Everything is a number?
Everything in the computer is stored as a pattern of bits
Numbers are stored as a pattern of bits
Computers use the binary number system
Characters are stored as a pattern of bits
Binary distinctions are easy for hardware to work with
One byte (8 bits) can represent one of 256 characters
So, is everything in the computer stored as a number?
No it isn’t, it’s stored as a bit pattern
There are many ways to interpret a bit pattern
Counting
To count up in any number system,
add 1 to the rightmost digit
if the result is higher than the largest digit,
set that digit to zero and carry to the next place
repeat addition of 1 and carrying as many times as necessary
Example: In hex, 4A6FF + 1 = 4A700
Counting in three systems
Dec
0
1
2
3
4
5
6
7
8
9
10
Bin
0
1
10
11
100
101
110
111
1000
1001
1010
Hex
0
1
2
3
4
5
6
7
8
9
A
Dec
Bin
Hex
11
12
13
14
15
16
17
18
19
20
1011
1100
1101
1110
1111
10000
10001
10010
10011
10100
B
C
D
E
F
10
11
12
13
14
Computers use binary numbers
People like to use decimal numbers
Computers use binary numbers
Java translates decimal numbers into binary
The computer does all its arithmetic in binary
Java translates binary results back into decimal
You occasionally have to use numbers in other
number systems
Colors are usually specified in hexadecimal notation:
#FF0000, #669966,
Using octal and hex numbers
Computers use binary, but the numbers are too long and
confusing for people--it’s easy to lose your place
Octal or hex is better for people
Translation between binary and octal or hex is easy
One octal digit equals three binary digits
101101011100101000001011
5 5 3 4 5 0 1 3
One hexadecimal digit equals four binary digits
101101011100101000001011
B
5
C
A
0
B
Writing octal and hex integers
Integers are usually written in decimal notation:
7, 532, -28
To write a number in octal, just start with a zero:
02, 0657, -077
...but don’t use the digits 8 or 9 !
To write a number in hexadecimal, start with 0x or 0X:
0xA, 0X43AB5, -0xFFFF
The “digits” A through F can be upper or lower case
Uppercase is usually preferred
Lowercase is more readable for long numbers
Integer types
There are four integer types
byte – occupies one byte (surprise!)
short – occupies two bytes
Can hold numbers in range –32768 to 32767
int – occupies four bytes
Can hold numbers in range –128 to 127
Can hold numbers up to + or – 2 billion
long – occupies eight bytes
Can hold numbers up to about 19 digits
Literals are written with an L suffix: 123456789L
A lowercase L can be used, but it’s a bad idea: 123456789l
Floating-point literals
Floating-point literals are written with a decimal point:
8.5 -7.923 5.000
Floating-point numbers may also be written in
“scientific notation”– times a power of 10
We use E to represent “times 10 to the”
Example: 4.32E5 means 4.32 x 105
float literals are written with an F suffix
Examples: 8.5F
-7.923F
5.000F
4.32E5F
If you don’t have the F suffix, type double is assumed
Floating point types
There are two floating-point types
float – occupies four bytes
Can hold numbers in the range 3.4E38 to 1.4E-45
Accuracy is about nine digits
double – occupies eight bytes
Can hold numbers in the range 1.7E308 to 4.9E-324
Accuracy is seventeen or eighteen digits
Number “width”
Numeric types are considered wider or narrower
than other numeric types
This is based partly on number of bytes occupied
Also based on how large a number it can hold
Java doesn’t mind if you assign a narrow value to a
wide variable: int n = 3;
Java is not happy if you assign a wide value to a
narrow variable: byte b = 7139946; // illegal
Widening and narrowing
byte
short
int
long
float
double
You can always widen
(assign a narrower type to a
wider type):
double wide;
int narrow;
wide = narrow;
But if you want to narrow
(assign a wider type to a
narrower type), you have to
cast it:
narrow = (int)wide;
Casts
You can convert (cast) one numeric type to another
When you widen, no explicit cast is necessary
When you narrow, an explicit cast is required
But it doesn’t hurt
This requirement is made to help avoid errors
Casting tells Java that the value in the wider type
will fit in the narrower type
Java checks to make sure that the cast works, and
gives you an error if it didn’t
Example casts
short s = 0;
int i = 0;
double d = 0.0;
d = i; // legal
d = s; // legal
i = s; //legal
i = d; // illegal
s = d; // illegal
s = i; // illegal
i = (int) d;
// legal
s = (short) d; // legal
s = (short) i; // legal
d = 3.7E20;
i = 50000;
// The following give
// runtime errors:
s = (short) i;
i = (int) d;
The fifth integer type
The primitive type char refers to a single, two-byte Unicode
character
You can use characters in arithmetic (they will automatically be
converted to int)
There is no good reason this should be a numeric type...
...but characters were numbers in C
char ch = 'A';
char ch2 = (char) (ch + 1); // cast result back to char
System.out.println(ch + " " + ch2 + " " + (ch + 1));
A B 66
To assign a char to a byte, or a byte to a char, you must use a
cast
Mixed types
If you mix numeric types, the narrower type is
automatically promoted to the wider type
int narrow = 5;
double wide;
double anotherWide = wide + narrow;
Integer division is when you divide one integer type by
another; the fractional part is discarded
Example: narrow = 19 / 5; // result is 3
Math methods
Converting a double to an int just discards the fractional part:
(int)17.93 is 17
(int) –17.93 is -17
double Math.floor(double)
Given a double, returns (as a double) the largest integral value not greater
than the argument
Math.floor(17.93) returns 17.0
Math.floor(-17.93) returns –18.0
double Math.ceil(double)
Given a double, returns (as a double) the smallest integral value not
smaller than the argument
Math.ceil(17.93) returns 18.0
Math.ceil(-17.93) returns –17.0
Method parameters
When you send a message to an object with a numeric
parameter, and the object needs to promote the
parameter in order to use a method, it will do so
Example:
double twice(double n) { return 2.0 * n; }
twice(5) returns 10.0
This promotion will only occur if necessary
Example 2:
double half(double n) { return n / 2; }
int half(int n) { return n / 2; }
half(25) returns 12
The End