Java Primitives
The Smallest Building Blocks of
the Language
(corresponds with Chapter 2)
Terminology









Primitive Data Type – a category of data. A description of how
the computer will treat bits found in memory.
Variable – a named location in memory, treated as a particular
data type, whose contents can be changed.
Constant – a named location in memory, treated as a particular
type, whose contents cannot be changed.
Declaration – the act of creating a variable or constant and
specifying its type.
Literal – a hard-coded piece of data, part of the statement and not
based on a variable or constant declaration.
Operator – a symbol that describe how to manipulate data and
variables in memory
Expression – a combination of operators, variables, constants
and/or literals that produces a resulting piece of data
Assignment – copying the results of an expression into a variable.
Statement – a program instruction telling the CPU what to do. (All
statements end with semicolon).
Java Primitive Data types
 boolean -- true/false
 char -- Unicode
character (good for
internationalization)
 byte -- 8-bit signed
integer
 short --16-bit signed
integer
 int -- 32-bit signed
integer
 long -- 64-bit signed
integer
 float -- 32-bit
floating point
number
 double -- 64-bit
floating point nbr
Identifiers


Identifier = the name of a variable, constant, class, or
method
Rules for using identifiers:





An identifier must start with a letter, an underscore, or a
dollar sign.
An identifier cannot contain operators, such as
+, -, and so on.
An identifier cannot be a reserved word. (See Appendix A,
“Java Keywords,” for a list of reserved words).
An identifier cannot be true, false, or
null.
An identifier can be of any length.
Declaring Variables
int x;
// declares x to be an
// integer variable;
double radius; // declares radius to
// be a double variable;
char a;
General format:
datatype identifier;
// declares a to be a
// character variable;
Declaring multiple variables of the
same type:
datatype identifier1, identifier2,
identifier3;
Assignment Statements
x = 1;
// Assign 1 to x;
radius = 1.0;
// Assign 1.0 to radius;
a = 'A';
// Assign 'A' to a;
These expressions are all just Literals!
General format:
VariableIdentifier = expression;
Note: the = sign is an assignment
operator. It is NOT a test for equality.
assignment
declaration
Declaring and Initializing
in One Step

int x = 1;

double d = 1.4;

float f = 1.4f;

char a = ‘a’;
NOTE: by default floating point
literals are assumed to be doubles.
If you want to assign a floating
point literal to a float variable, you
must append the “f” to the end of
the number.
Note: character literals are enclosed in
single quotes
Constants
final datatype CONSTANTNAME = VALUE;
final double PI = 3.14159;
final int SIZE = 3;
The final modifier indicates
that the identifier refers to
a constant, not a variable.
Constants must be
initialized when declared.
Numeric Literals

int i = 34;

long l = 1000000;

float f = 100.2f;
or
float f = 100.2F;

double d = 100.2d
or
double d = 100.2D;
Common Types of Operators

Assignment =

Arithmetic
+
-
*
/
%
modulus

Comparison == <
equals

Logical
&&
AND
>
<= >= !=
not equals
||
OR
!
NOT
^
Exclusive
OR
Modulus (remainder) Operator
Modulus 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 you know January 1, 2005 is
Saturday, you can find that the day for February
1, 2005 is Tuesday using the following expression:
Saturday is the 6th day in a week
A week has 7 days
(6 + 31) % 7 is 2
January has 31 days
The 2nd day in a week is Tuesday
Common Types of Expressions

Arithmetic



Combine numeric data with arithmetic operators
Return a number
Conditional



Combine boolean values with logical operators
Boolean values can be derived from comparison
operators or boolean data values
Returna boolean value
Arithmetic Expressions
1 + 1
 x * y
 5 / 2
 5 % 2
 radius*radius*3.14159

Sample Statements with
Arithmetic Expressions
//Compute the first area
radius = 1.0;
area = radius*radius*3.14159;
//Compute the second area
radius = 2.0;
area = radius*radius*3.14;
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)
Shortcut Operators
Operator Example
Equivalent
+=
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
Increment and
Decrement Operators

x = 1;
x++;
x--;

y = 2 + x++;
X is incremented after adding to 2

X is incremented before adding to 2

y = 2 + ++x;
y = 2 + x--;

y = 2 + --x;
X is decremented before adding to 2


++x;
--x;
Add 1 to x
Subtract 1 from x
X is decremented after adding to 2
Increment and
Decrement Operators, cont.
int i = 10;
int newNum = 10 * i++;
Same effect as
int i = 10;
int newNum = 10 * (++i);
int newNum = 10 * i;
i = i + 1;
Same effect as
i = i + 1;
int newNum = 10 * i;
Integer vs. Floating Point Division
When performing operations involving two operands of
different types, Java automatically converts the
operand of a smaller range to the data type of the
larger range.
Example:
1/2
 this will give 0 because both operands
are integer
1.0/2
or
1/2.0
 this will give 0.5
because the floating point literal is a double,
so the integer literal (long) will be converted
to a double; thus floating point division will
take place.
Character Data Type

char letter = 'A';

char letter = '\u00041';

char numChar = '4';
Unicode
representation
Java uses Unicode instead of ASCII for character data
representation
Character Escape Sequences
Backspace
\b
Tab
\t
Linefeed
\n
Carriage return
\r
Backslash
\\
Single quote
\'
Double quote
\"
The boolean Data Type

boolean lightsOn = true;

boolean lightsOn = false;

boolean test = 1==1;


Returns true
boolean test = 1==2;

Returns false
comparison expressions
The + symbol as concatenation
operator
System.out.println("The area is "
+ area
+ " for radius "
+ radius);
Here, the + is used to
concatenate strings together
String literals are enclosed in double quotes
Boolean Operators Revisited
Operator Name
!
not
&&
and
||
or
^
exclusive or
Truth Table for Operator !
p
!p
true
false
!(1 > 2) is true, because (1 > 2) is false.
false
true
!(1 > 0) is false, because (1 > 0) is true.
Example
Truth Table for Operator &&
p1
p2
p1 && p2
false
false
false
false
true
false
true
false
false
true
true
true
Example
(3 > 2) && (5 >= 5) is true, because (3 >
2) and (5 >= 5) are both true.
(3 > 2) && (5 > 5) is false, because (5 >
5) is false.
Truth Table for Operator ||
p1
p2
p1 || p2
false
false
false
false
true
true
true
false
true
true
true
true
Example
(2 > 3) || (5 > 5) is false, because (2 > 3)
and (5 > 5) are both false.
(3 > 2) || (5 > 5) is true, because (3 > 2)
is true.
Truth Table for Operator ^
p1
p2
p1 ^ p2
false
false
false
false
true
true
true
false
true
true
true
false
Example
(2 > 3) ^ (5 > 1) is true, because (2 > 3)
is false and (5 > 1) is true.
(3 > 2) ^ (5 > 1) is false, because both (3
> 2) and (5 > 1) are true.
Numeric Type Conversion
Consider the following statements:
byte i = 100;
long k = i * 3 + 4;
double d = i * 3.1 + k / 2;
Conversion Rules
When performing a binary 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.
Type Casting
Implicit casting
double d = 3; (type widening)
Explicit casting
int i = (int)3.0; (type narrowing)
int i = (int)3.9; (Fraction part
is truncated)
Cast operator
Operator Precedence









Casting
++, -*, /, %
+, <, <=, >, =>
==, !=;
&&
||
=, +=, -=, *=, /=, %=
first
last
Parentheses can be used to override normal precedence