Download to read offline
DataType and variables in oop's using Java
- 1. Data types, declarations,and expressions in Java
- 2. Variables • A variableis 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
- 3. 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
- 4. 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.
- 5. Numeric data typesin 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
- 6. Numeric data typesin 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
- 7. 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
- 8. Scientific notation andreal 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
- 9. Assignment statements • Wecan 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
- 10. Arithmetic expressions • Anexpression 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
- 11. Arithmetic operators inJava • Compound expressions are formed by combining simple expressions using arithmetic operators Operation Symbol Addition + Subtraction - Multiplication * Division / Modulus %
- 12. Arithmetic operations inJava • 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
- 13. Examples int x =4, y = 9, z; z = x + y * 2; // result is 22 z = (x + y) * 2; // result is 26 y = y – 1; // result is 8
- 14. Integer division • Whenone 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
- 15. Integer division • Thereare 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 0 z = y % x; // result is 1 z = x % y; // result is 4
- 16. Mixed-type expressions • Amixed-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
- 17. 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)
- 18. Explicit type casts- examples int x = 2, y = 5; double z; z = (double) y / z; // z = 2.5 z = (double) (y / z); // z = 2.0
- 19. Assignment conversion • Anotherkind 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
- 20. No demotions inassignment 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.0 x = y; // error: can’t demote value to int y = y / 3; // y now contains 3.3333333333333333 x = (int)y; // allowed; x = 3
- 21. Compound arithmetic/assignment operators • Previousexamples 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
- 22. Compound arithmetic/assignment operators Operator UseMeaning += 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;
- 23. Named constants • Avariable 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 ;
- 24. Named constants • Thename 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
- 25. 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?
- 26. 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));
- 27. Calculations using Java’sMath 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
- 28. 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
- 29. 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
- 30. 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
- 31. Example // computing theroots 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);