Data types, declarations, and

expressions in Java

Variables
A variable is a named memory location
capable of storing data
As we have already seen, object variables
refer to objects, which are created by
instantiating classes with the new operator
We can also store data in simple variables,
which represent data only, without any
associated methods

Data declaration syntax

The syntax for the declaration of a variable
is:
Data type identifier;
data type may be the name of a class, as we
have seen, or may be one of the simple types,
which well see in a moment
identifier is a legal Java identifier; the rules
for simple variable identifiers are the same as
those for object identifiers

Variable declaration: examples

For example:
int age;// int means integer
double cashAmount;// double is a real #
We can also declare multiple variables of the same type using
a single instruction; for example:
int x, y, z; //
or
int
x,
y,
z;
The second way is preferable, because its easier to document
the purpose of each variable this way.

Numeric data types in Java:

integers
Data type name

Minimum value

Maximum value

byte

-128

127

short

-32,768

32,767

int

-2,147,483,648

2,147,483,647

long

9,223,372,036,85
4,775,808

9,223,372,036,85
4,775,807

Numeric data types in Java:

floating-point numbers
Data type
name
float

Minimum value

Maximum value

-3.40282347 x 1038

3.40282347 x 1038

double

1.79769313486231
570 x 10308

1.79769313486231
570 x 10308

Numeric data types: some notes

Most programmers use int for whole numbers and
double for real numbers
Numeric data types in Java are primitive (nonobject) types; this means that a numeric variable is
somewhat different from an object:
You dont use the new operator to initialize a numeric
variable just assign it a value
Memory for a numeric variable is allocated at declaration
Numeric variables actually store values; object names
store addresses

Scientific notation and real

numbers
Both float and double have wide ranges to the values they
can represent
In order to save space, particularly large or small values
are often displayed by default using a variation of
scientific notation
For example, the value .0000258 would appear as 2.58 x
10-5 in conventional notation as output from a Java
program, the number would appear as 2.58e-5
The e is for exponent, and can be upper or lowercase

Assignment statements
We can store a value in a variable using an
assignment statement
Assignment statement syntax:
variableName = expression;
variableName must be the name of a declared
variable
expression must evaluate to an appropriate
value for storage within the type of variable
specified

Arithmetic expressions
An expression is a set of symbols that represents a
value
An arithmetic expression represents a numeric value
Simple expressions are single values; examples:
18
-4
1.245e3

Previously-declared and initialized variables or

constants can also be simple expressions

Arithmetic operators in Java

Compound
expressions are
formed by
combining simple
expressions using
arithmetic
operators

Operation

Symbol

Addition

Subtraction

Multiplication

Division

Modulus

Arithmetic operations in Java

As in algebra, multiplication and division (and modulus,
which well look at momentarily) take precedence over
addition and subtraction
We can form larger expressions by adding more
operators and more operands
Parentheses are used to group expressions, using the same rule
as in algebra: evaluate the innermost parenthesized expression
first, and work your way out through the levels of nesting
The one complication with this is we have only parentheses to
group with; you cant use curly or square brackets, as they
have other specific meanings in Java

Examples
int x = 4, y = 9, z;
z = x + y * 2;
z = (x + y) * 2;
y = y 1;

// result is 22
// result is 26
// result is 8

Integer division
When one real number is divided by another, the
result is a real number; for example:
double x = 5.2, y = 2.0, z;
z = x / y;
// result is 2.6

When dividing integers, we get an integer result

For example:
int x = 4, y = 9, z;
z = x / 2;
// result is 2
z = y / x;
// result is 2, again
z = x / y;
// result is 0

Integer division
There are two ways to divide integers
using the / operator, produces the quotient of the two
operands
using the % operator, produces the remainder when
the operands are divided. This is called modular
division, or modulus (often abbreviated mod). For
example:
int
z =
z =
z =

x
x
y
x

=
%
%
%

4, y = 9, z;
2; // result is 0
x; // result is 1
y; // result is 4

Mixed-type expressions
A mixed-type expression is one that involves operands of
different data types
Like other expressions, such an expression will evaluate to a single
result
The data type of that value will be the type of the operand with the
highest precision
What this means, for all practical purposes, is that, if an
expression that involves both real numbers and whole
numbers, the result will be a real number.

The numeric promotion that takes place in a mixed-type

expression is also known as implicit type casting

Explicit type casting

We can perform a deliberate type conversion of an
operand or expression through the explicit cast
mechanism
Explicit casts mean the operand or expression is
evaluated as a value of the specified type rather
than the type of the actual result
The syntax for an explicit cast is:
(data type) operand
-or(data type) (expression)

Explicit type casts - examples

int x = 2, y = 5;
double z;
z = (double) y / z;
z = (double) (y / z);

// z = 2.5
// z = 2.0

Assignment conversion
Another kind of implicit conversion can
take place when an expression of one type
is assigned to a variable of another type
For example, an integer can be assigned to a
real-number type variable; in this case, an
implicit promotion of the integer value
occurs

No demotions in assignment
conversions
In Java we are not allowed to demote a higherprecision type value by assigning it to a lowerprecision type variable
Instead, we must do an explicit type cast. Some
examples:
int x = 10;
double y = x;
x = y;
y = y / 3;
x = (int)y;

// this is allowed; y = 10.0

// error: cant demote value to int
// y now contains 3.3333333333333333
// allowed; x = 3

Compound arithmetic/assignment
operators
Previous examples in the notes have included the following
statements:
y = y + 1;
y = y / 3;

In each case, the current value of the variable is used to

evaluate the expression, and the resulting value is assigned to
the variable (erasing the previously-stored value)
This type of operation is extremely common; so much so, that
Java (like C++ and C before it) provides a set of shorthand
operators to perform this type of operation. The table on the
next slide illustrates the use and meaning of these operators

Compound arithmetic/assignment
operators
Operator

Use

Meaning

+=

X += 1;

X = X + 1;

-=

X -= 1;

X = X 1;

*=

X *= 5;

X = X * 5;

/=

X /= 2;

X = X / 2;

%=

X %= 10;

X = X % 10;

Named constants
A variable is a named memory location that can hold a
value of a specific data type; as we have seen, the value
stored at this location can change throughout the execution
of a program
If we want to maintain a value in a named location, we use
the Java keyword final in the declaration and immediately
assign the desired value; with this mechanism, we declare
a named constant. Some examples:
final int LUCKY = 7;
final double PI = 3.14159;
final double LIGHTSPEED = 3.0e10.0 ;

Named constants
The name of the constant is used in expressions but cannot
be assigned a new value. For example, to calculate the
value of variable circleArea using the variable radius and
the value , we could write:
circleArea = 2 * PI * radius * radius;

The use of named constants is considered good

programming practice, because it:
eliminates (or at least minimizes) the use of magic numbers in a
program; it is easier to read code that contains meaningful names
allows a programmer to make global changes in calculations easily

Using named constants: example

Suppose, for example, that you are writing a
program that involves adding sales tax and
subtracting discounts from users totals
If the tax rate is 5% and the discount rate is 10%,
the calculation could look like this:
total = total (total * .1) + ((total * .1) * (1 + .05));

By itself, this isnt too bad; but suppose there are

several places in the program that use these
values?

Example continued
If, for example, the discount changes to 12%, the
programmer who has to maintain the code would have to
change the value .1 to .12 everywhere in the program
at least, everywhere that it actually refers to the discount.
The value .1 could very well mean something else in a
different expression.
If we use named constants instead, the value has to change in
just one place, and there is no ambiguity about what the
number means in context; with named constants, the revised
code might read:
total = total (total * discount) + ((total * discount) * (1 + taxrate));

Calculations using Javas Math

class
The standard Java class Math contains class
methods and constants that are useful in
performing calculations that go beyond
simple arithmetic operations
The constants defined in the Math class are
Math.PI and Math.E, which are defined
values for and e (the base for natural logs),
respectively

Math class methods

Math.abs(a): returns the absolute value of its
argument (a), which can be of type int, long, float,
or double
Math.sin(a): returns the sine of its argument, a
double value representing an angle in radians;
similar trigonometric functions include
Math.cos(a) for cosine, Math.tan(a) for tangent,
Math.acos(a), Math.asin(a) and Math.atan(a),
which provide arccosine, arcsine, and arctangent,
respectively

Math class methods

Math.toDegrees(a): converts a, a double
value representing an angle in radians, to
the corresponding value in degrees
Math.toRadians(a): converts a, a double
value representing an angle in degrees to
the corresponding value in radians

Math class methods

Math.sqrt(a): returns the square root of a, a value
of type double
Math.cbrt(a): returns the cube root of a, a value
of type double
Math.pow(a, b): returns the value of ab
Math.log(a): returns the natural log of a, a double
value
Math.log10(a): returns the log base 10 of a, a
double value

Example
// computing the roots of a quadratic equation:
double
a,
// coefficient of x squared
b,
// coefficient of x
c,
// 3rd term in equation
x1,
// first root
x2;
// second root
// read in values for a, b, and c not shown here
x1 = (-b + Math.sqrt(Math.pow(b, 2) (4 * a * c))) / (2 * a);
x2 = (-b - Math.sqrt(Math.pow(b, 2) (4 * a * c))) / (2 * a);