Transcript Data types, declarations, and expressions in Java

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 we’ll 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 it’s 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,854,775,808
9,223,372,036,854,775,807
Numeric data types in Java:
floating-point numbers
Data type name
Minimum value
Maximum value
float
-3.40282347 x 1038
3.40282347 x 1038
double
-1.79769313486231570 x 10308
1.79769313486231570 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 don’t 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 we’ll 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 can’t 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
(data type) (expression)
-or-
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: can’t 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 isn’t 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 Java’s 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);