Why do we need

variables?

Why do we need
variables?

Java Basics:
Variables & Data Types

Variables and Values

Variables store data such as numbers

and letters
Think of them as places to store data
They are implemented as memory locations

The data stored by a variable is called

its value
The value is stored in the memory location

Its value can be changed

Variables
Variables have two attributes: a name and a type
We will consider these two attributes one at a time. First
let us consider names

Java Identifiers
An identifier is a name, such as the name of a variable, a
method, or a class.

Identifiers may contain only

letters (both lower & upper case)
digits (0 through 9)
and the underscore character (_)

but the first character cannot

be a digit.

Java Identifiers, cont.

Identifiers may not contain any spaces, dots (.),
asterisks (*), or other characters:
seven-eleven

netscape.com

util.* (are not allowed)

Java is case sensitive, thus stuff, Stuff, and STUFF

are different identifiers
Identifiers can be arbitrarily long

Keywords or Reserved Words

Some words, such as public, are called keywords
or reserved words and have special, predefined
meanings
Keywords cannot be used as identifiers
Other keywords: static, void, class
We will be introduced to many more

Naming Conventions
Java uses the following conventions:
Variable names and method names, regardless of
their type, begin with a lowercase letters (e.g. myName,
processData)
Multiword names are punctuated using uppercase letters
(usually called camel case)

Class names begin with an uppercase letter (e.g.

String or PrintStream)
Names should be meaningful and/or descriptive

Variables
Variables have two attributes: a name and a type
Next let us consider types

Data types
Internally, computers store everything as 1s and 0s
154
"hi"

0000000010011010
0110100001101001

We need to tell the computer how to interpret a given

sequence of 1s and 0s, and how to operate on it
A type defines a category or set of data values
It also defines the operations that can be performed on the data

Javas Primitive Types

Four integer types (byte, short, int, and long)
We will always use the int type

Two floating-point types (float and double)

We will always use the double type

One character type (char)

One boolean type (boolean)

Types that are not primitive are called object types (seen later)

Javas Primitive Types, cont.

Examples of Primitive Values

Integer types
0

-1

365

12000

Floating-point types
0.99

-22.0

3.14159

-0.25

9.4e3

Character type
'a'

'A'

'#'

boolean type
true

false

(use single quote mark)

Variables
Variables have two attributes: a name and a type
Now that we know about names and types, we can
combine them to declare variables

Declaring Variables
When you declare a variable, you provide its type and
name:
int numberOfRings;

You specify a type that you want

Declaring Variables
When you declare a variable, you provide its type and
name:
int numberOfRings;

And you specify the name that you want

Declaring Variables
When you declare a variable, you provide its type and
name:
int numberOfRings;

A variable must be declared before it is used

Choose names that are descriptive

Such as numberOfRings rather than n

Declaring Variables
Syntax:
type

variable_1, variable_2, ;

Examples (from the traveling circus):

int numberOfRings, attendance;
double ringDiameter, weightOfLion;
boolean lionWasFed;

Where to Declare Variables

Declare a variable
just before it is used for the first time, or
at the beginning of the section of your program that
is enclosed in { }
public void process( )
{
// declare variables here
}

Java Basics:
Variables and Assignment

Assignment Statements
An assignment statement is used to assign a value
to a variable
answer = 42;

The equal sign is called the assignment operator

It does not mean equality in the mathematical sense

We say, answer is assigned the value 42.

Assignment Statements, cont.

Syntax:
variable = expression;

where expression can be another variable, a constant

(such as a number), or something more complicated
which combines variables and constants using
operators (more on this in a moment).
The variable is always on the left and the expression is
always on the right.

Assignment Examples
numOfStacks = 4;
topCard = 'Q';
points = 10 * cardsPlayed;

Assignment Evaluation
1.

The expression on the right-hand side of the

assignment operator (=) is evaluated first

Assignment Evaluation
1.

The expression on the right-hand side of the

assignment operator (=) is evaluated first

2.

Then the result is used to set the value of the variable

on the left-hand side of the assignment operator

Assignment Evaluation
1.

The expression on the right-hand side of the

assignment operator (=) is evaluated first

2.

Then the result is used to set the value of the variable

on the left-hand side of the assignment operator

cardsInHand = cardsInHand - 1;
Before assignment

cardsInHand

Assignment Evaluation
1.

The expression on the right-hand side of the

assignment operator (=) is evaluated first

2.

Then the result is used to set the value of the variable

on the left-hand side of the assignment operator

cardsInHand = cardsInHand - 1;
After assignment

cardsInHand

Using variables
Once given a value, a variable can be used in expressions,
and can assign a value more than once :
int
x =
y =
z =
x =
...

x, y, z;
3;
2 * x;
5 + x*y;
4 + y;

//
//
//
//

x
y
z
x

is
is
is
is

3
6
23
now 10

Java Basics:
Expressions

Expressions
An expression is value or operation that computes a value
Examples:

5 + 14
8 / 2 * (4 + 3)
17

The simplest expression is a literal value

Such as the literal value 17 above

A complex expression can use operators and parentheses

Arithmetic Operators
Arithmetic expressions can be formed using operators
which allow us to combine values referred to as the
operands
Arithmetic operators include:
+
*
/
%

addition
subtraction (or negation)
multiplication
division
modulus (a.k.a. mod or remainder)

The Division Operator

The division operator (/) behaves as expected if one of
the operands is a floating-point type
When both operands are integer types, the result is
truncated, not rounded, to produce an integer value
Thus, 14/4 produces the value 3

If you want a floating-point result, at least one operand

must be a floating-point type
Both 14/4.0 and 14.0/4 produce the value 3.5

The mod Operator

The mod (%) operator is used with operands of integer
type to obtain the remainder after integer division
14 divided by 4 is 3 with a remainder of 2
Hence, 14%4 produces the value 2
The mod operator has many uses, including
determining if an integer is odd or even
determining if one integer is evenly divisible by another integer
obtaining the lower-ordered digits of a number

Parentheses and Precedence

As in algebra, parentheses can communicate the order
in which arithmetic operations are performed
examples:
(10 + 213) * 37
10 + (213 * 37)

Without parentheses, an expression is evaluated

according to the rules of precedence

Precedence Rules

Precedence Rules
When binary operators have equal precedence, they are
evaluated left-to-right.
1+2-3+4 is the same as ((1+2)-3)+4

When unary operators have equal precedence, they are

evaluated right-to-left.

Mixing types
When int and double are mixed, the result is a double
4.2 * 3 is 12.6

The conversion is per-operator, affecting only its operands

7 / 3 * 1.2 + 3 / 2
\_/
|
2
* 1.2 + 3 / 2
\___/
|
2.4
+ 3 / 2
\_/
|
2.4
+
1
\________/
|
3.4

Java Basics:
More on Assignment

Specialized Assignment Operators

Assignment operators can be combined with arithmetic
operators (including +, -, *, /, and %)
time = time + 10;

can be written as
time += 10;

yielding the same results

Specialized Assignment Operators

Shorthand
variable +=
variable -=
variable *=
variable /=
variable %=

expr;
expr;
expr;
expr;
expr;

Equivalent longer version

variable = variable + (expr);
variable = variable - (expr);
variable = variable * (expr);
variable = variable / (expr);
variable = variable % (expr);

Increment (and Decrement) Operators

used to increase (or decrease) the value of a variable by 1

easy to use, important to recognize

the increment operator is ++
count++ or ++count
the decrement operator is --
count-- or --count

Increment (and Decrement) Operators

Equivalent statements:
count++;
++count;
count = count + 1;
count += 1;

Also:
count--;
--count;
count = count - 1;
count -= 1;

Increment (and Decrement) Operators

The increment operator also produces a value
Pre-increment: ++count
Increments the variable and returns the new value

Post-increment: count++
Increments the variable but returns the original value

Most often, we use these to simply increment a variable

and we dont care about the return value
In which case, you can use either one
This occurs when increment is the only operation in a statement

Initializing Variables
A variable that has been declared, but not yet
given a value is said to be uninitialized
The compiler will not allow you to use an
uninitialized variable
To protect against an uninitialized variable (and to
keep the compiler happy), it is good practice to
assign a value at the time the variable is declared

Declaration & initialization

A variable can be declared & initialized in one statement
Syntax:
type name = value;

char grade = 'A';

int score = (14 % 4) + 10;

grade

score

12

Assignment Compatibilities
Java is said to be strongly typed
You cant, for example, assign a floating point value to a variable
declared to store an integer
int myNumber = 7.5; // Error: Compiler will not allow

Assignment Compatibilities
Sometimes conversions between numbers are possible
double myVariable = 7;

// this is OK

It is okay to assign an integer value to a variable of type

double

In this case, the compiler will automatically convert the

integer 7 into a floating point 7.0
This automatic conversion is called a coercion

Assignment Compatibilities
A value of one type can be assigned to a variable of any
type further to the right
byte --> short --> int --> long --> float --> double

but not to a variable of any type further to the left.

E.g., you can assign a value of type char to a variable of

type int, or a value of type int to a variable of type
double, but you cannot assign a value of type double to
a variable of type int.

Type Casting
A type cast temporarily changes the value of a variable
from the declared type to some other type. It does not
change the variable.
For example,
double distance;
distance = 9.0;
int points;
points = (int)distance;

the above is illegal without the (int)

Type Casting, cont.

The value of (int)distance is 9, but the value of
distance, both before and after the cast, is 9.0
Any nonzero value to the right of the decimal point is
truncated rather than rounded
Thus if the value of distance was 9.7, the value of
the expression (int)distance would still be 9
Again, the value of the variable distance is not
changed and would still be 9.7