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 integerdouble 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; //orint 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 (non-object) 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-41.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; // result is 22z = (x + y) * 2; // result is 26y = y – 1; // 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 x = 4, y = 9, z;z = x % 2; // result is 0z = y % x; // result is 1z = x % 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 = 2.5z = (double) (y / z); // 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 higher-precision type value by assigning it to a lower-precision type variable

• Instead, we must do an explicit type cast. Some examples:int x = 10;double y = x; // this is allowed; y = 10.0x = y; // error: can’t demote value to inty = y / 3; // y now contains 3.3333333333333333x = (int)y; // 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 xc, // 3rd term in equationx1, // first rootx2; // 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);