data types, declarations, and expressions in java
Post on 19-Dec-2015
233 views
TRANSCRIPT
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);