Download Data Types and Operations On Data

Data Types and Operations On Data
Objective
• To understand what data types are
• The need to study data types
• To differentiate between primitive types and reference types
• To know the data range and storage requirements for each type
• To know the conditions for data conversion
• To know the permissible operations that can be performed on data
• To be able to evaluate expressions
Data Types and Operations On Data
•
Introduction
•
Data Types
•
Primitive Type

Integral Type

Floating Point Type

Character Type

Boolean Type
•
Type Compatibility
•
Reference Type
•
Arithmetic Operator and Operations
•
Arithmetic Expressions
•
Relational Operator and Operations
•
Relational Expressions
•
Logical Operator and Operations
•
Input and Output Operations
Data Types - Introduction
•
The concept of data type is like what the bolts and nuts are to a piece of
machinery.
•
It is impossible to write meaningful program, without understanding:
 Data types, data values
 The amount of memory required for each type of data, and
 The permissible operations that can be performed on data
Data Types - Introduction
•
Like anything else, conservation of the use of memory is important.
•
Some former languages did not consider conserving memory.
•
Most of them had only two ways to store numeric values:
 int, for integers, and
 float, for floating point values.
•
Hence wasting memory, especially when storing small values ;
•
The amount of memory for each value, large or small, is the same.
Introduction – Data Types
•
In the first section we:
a)
Study the fundamental data types in Java, and
b)
how they relate to programming.
c)
Focus on the operations that can be performed on each type.
•
The second section introduces the reference type.
•
This includes some of the fundamental Java classes, such as:
a)
The String class
b)
The Math class
c)
The wrapper classes
The Fundamental Types
•
We had established that data is vital to a program.
•
It must be stored in primary memory for the processor to handle it.
•
The Java specifies two broad categories of data types:
a)
Primitive, and
b)
Reference type
•
Primitive types are atomic
•
They cannot be decomposed into simpler types
•
Reference types are constructed from:
a)
Primitive types,
b)
As well as from other reference types
Data Types
Data types
Primitive types
Floating Point
Integral types
Reference types
Boolean types
Java classes
User defined classes
Integers
byte
int
Character
short
long
char
float
double
boolean
Primitive Types
•
Primitive types are atomic
•
There are three types – integral, floating point, and boolean
•
Integral – they can be represented by an integer value
•
There are two groups – integer and character
•
Integer – byte, short, int, long
Integer Type
Data types
Storage Required
Range of Values
byte
8 bits (byte)
-128 to +127
short
16 bits (2 bytes)
-32,768 to +32,767
int
32 bits (4 bytes)
-2,147,483,648 to +2,147,483,647
long
64 bits (8bytes)
-9,223,372,036,854,775,808 to
+9,223,372,036,854,775,807
Floating Point Type
Data Type
Storage required
Range of Values
float
32 bits (4 bytes)
-3.4 x 1038 to +3.4 x 1038
double
64 bits (8 bytes)
-1.7 x 10308 to +1.7 x 10308
Storage Space
byte
short
int
long
Default Values
•
Integer types – 0
•
Floating point types – 0.0
Assignment Incompatibility
•
Variables can be initialized wrongly
•
This situation gives rise to syntax errors
•
Consider the following statement:
int x = 2.0;
Configuration: j2sdk1.4.1_02 <Default>---C:\chapter3\unicodeChar.java:5: possible loss of precision
found : double
required: int
int x = 2.0;
^
1 error
Process completed
Assignment Incompatibility
•
Consider the following statement:
short x = 150000;
•
This gives rise to syntax error also.
Configuration: j2sdk1.4.1_02 <Default>---C: \chapter3\unicodeChar.java:5: possible loss of precision
found : int
required: short
short x = 150000;
^
1 error
Process completed
Assignment Incompatibility
Consider the following segment of code:
int x = 2;
byte y = x;
-----Configuration: j2sdk1.4.1_02 <Default>---C:\istings\data_types\default_types.java:6: possible
loss of precision
found : int
required: byte
byte y = x;
^
1 error
Process completed.
Character type - char
•
The character data type named char is :

Any printable symbol found on the keyboard, or

Certain sequence of characters called escape sequence.
•
In either case, it requires 16 bits (2 bytes) of memory to store the char value
•
A char value can be represented decimal value in the range 0 to 65,536, or as
Unicode character in the range ‘\u0000” to ‘\uFFFF’
Data type
Storage Required
Range in Decimal
Range in Unicode
char
16 bits (2 bytes)
0 to 65,536
\u0000 to \uFFFF
Boolean Type
•
Java’s logical data type is called boolean.
•
The set of values that represent the boolean data type is true and false.
•
•
This data type is implemented when comparing primitive types.
Boolean variables are declared the same way as other variables
•
•
The default of a boolean variable is false
Consider the following statement
boolean x = 0;
Configuration: j2sdk1.4.1_02 <Default>---C: \chapter3\unicodeChar.java:5: incompatible types
found : int required: boolean
boolean x = 0;
^
1 error
Process completed.
Operator and Operations on Data
•
Computers are known as number crunching machines.
•
To crunch numbers, they need to perform operations on the numbers
•
Java has five types of operations to perform on primitive data values:
 Arithmetic operations
 Relational operations
 Logical operations
 Bit-wise operations, and
 Bit-shift operations
•
We will study the first three – Arithmetic, Relational and Logical operations
Arithmetic Operator and Operations
• Java defines five binary arithmetic operators: +
• They are used to form arithmetic expressions.
• The format of an arithmetic expression is:
- *
/ %
operand operator operand;
• Operands are any valid identifier or numeric literal, and
• Operator is any of five arithmetic operators. See summarized below
Operator
Name
Algebraic form
Example
Result
+
Addition
x+y
25 + 15
40
-
Subtraction
x–y
25 - 15
10
*
Multiplication
x*y
18 * 2
36
/
Division
x/y
37 / 5
7
Modulus operation
x%y
37 % 5
2
%
The operator / vs %
•
•
The operators (+ , - , * ) have the usual arithmetic meaning
The operator ( / ), gives the quotient when applied to division
7
5 37
 35
___________
2
That is why: 37/5 = 7 , and not 7.4
• The operator ( % ), gives the remainder when applied to division
Hence, 37 % 5 = 2.
7
5 37
 35
___________
2
The operator / vs %
•
If a task takes a worker 127 minutes to complete, how many hours and how
many minutes did it take the person to complete.
•
If we were to program this, we would have to tell the computer precisely how
to carry out the calculation. That is:
 The number of hours would be (127 / 60) 2 hours, and
 The number of minutes would be (127 % 60) 7 minutes.
Example
•
A small company wants you to write a program to figure out the number of
boxes needed to ship book orders without wasting space. They have four types
of boxes: extra large, large, medium and small, which can hold 25, 15, 5 and 1
book(s) respectively.
•
Write a Java program that accepts the number of books to be shipped and
displays the number of boxes needed with their type. For example if the
company wants to ship 81 books your output should be 3 extra large boxes, 1
medium box and 1 small box.
Solution
•
As before let us identify the elements of the problem
•
Let us call the entity – PackingBooks
•
No list the characteristics (attributes) of PackingBooks
 Constants
 Variables
Constructor
•
•
Operations
 Methods
PackingBooks - Attributes
•
Constants
 Extra large box
 Large box
 Medium box
 Small box
•
Variables
 books
 extra large
 large
 medium
 small
 total_boxes
PackingBooks - Constructor
•
The problem suggests only one
argument required – the
number of books
• PackingBooks( books)
Accessor Methods
getExtraLargeBox()
getLargeBox()
getMediumBox()
getSmallBox()
Mutator Method
determineBoxes()
getTotalBoxes()
Class PackingBooks
1. public class Packing
2. {
3.
private static final int XTRA_LARGE_BOX
= 25,
4.
LARGE_BOX
= 15,
5.
MEDIUM_BOX
= 5,
6.
SMALL_BOX
= 1;
7.
8.
private int books;
9.
private int xlarge, large, medium, small, total_boxes;
10.
11.
public Packing(int books)
12.
{
13.
this.books = books;
14.
}
Class PackingBooks – Mutator Method
15.
16. void determineBoxes()
17. {
18.
xlarge = books/XTRA_LARGE_BOX;
19.
books = books % XTRA_LARGE_BOX;
20.
21.
large = books/LARGE_BOX;
22.
books = books % LARGE_BOX;
23.
24.
medium = books/MEDIUM_BOX;
25.
small = books % MEDIUM_BOX;
26.
27.
total_boxes = xlarge + large + medium + small;
28. }
Accessor Methods
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50. }
int getXtraLargeBox()
{
return big;
}
int getLargeBox()
{
return large;
}
int getMediumBox()
{
return medium;
}
int getSmallBox()
{
return small;
}
int getTotal()
{
return total_boxes;
}
Class PackingBooks – Test class
1. class TestPacking
2. {
3.
public static void main(String [] arg)
4.
{
5.
Packing pack = new Packing(127);
6.
pack.calculate();
7.
8.
System.out.println(pack.getXLarge()
+ " extra large boxes\n"
+ pack.getLarge()
9.
+ " large boxes\n" + pack.getMedium()
10.
+ " medium boxes\n" + pack.getSmall()
11.
+ " small box\n" + pack.getTotal()
12.
13.
14. }
+ " total boxes\n") ;
}
Integer Operations
Integer operations can produce erroneous results
Integer
oprations
Result
Example
Actual Result
Correct Result
int + int
number too large
2147483647 + 53
-2147483596
2147483700
int - int
number too large
-2147483647 - 53
2147483596
-2147483700
int * int
number too large
1000000000 * 500
1783793664
500000000000
int / int
Arithmetic Exception
125/0
ArithmeticException
No correct result
int % int
Arithmetic Exception
125 % 0
ArithmeticException
No correct result
Floating Point Operations
Floating -Point operations can produce erroneous results
Floating-Point Operations
Results
float + float
Infinity
float - float
-Infinity
float * float
Infinity
float / float
Infinity
-float / float
-Infinity
-float / 0.0
-Infinity
0.0/0.0
NaN
-float * float
-Infinity
Modulus operation ( % )
Same as division
Evaluate Arithmetic expressions
In general, arithmetic expressions are evaluated from left to right
2+3–4+5
–
2 + 3
5
1
6
4
+
5
Evaluate Arithmetic expressions
•
The order of evaluating an expression may be altered.
•
Criteria
 Parenthesize (sub-expressions) expressions have the highest priority.
 Multiplication, division and modulus have next level of priority
 Addition and subtraction have the lowest level of priority.
Evaluate Arithmetic expressions
The operations * / % must be carried out before addition and subtraction
2+3–4*5
2
+
3
–
4
*
20
5
-15
5
Evaluate Arithmetic expressions
The parentheses must be carried out before
2 + ( 3 – 4) * 5
2
+
–
( 3
4 )
-1
-5
-3
*
5
+
-
*
/
%
Evaluate Arithmetic expressions
11 % 4 * 2 – 14/3 + (8 –2 * -3)
11
%
4
*
–
2
14
/
3
+
( 8
–
2
*
-6
14
3
6
4
2
16
-3 )
Converting Algebraic Expression
s = s0 +v0t + ½ gt2
•
•
•
•
s = s0 + v0 * t + g * t * t / 2.0;
or
s = s0 + v0 * t +1.0/2 *g * t * t ;
or
s = s0 + v0 * t +0.5 *g * t * t ;
or
s = s0 + v0 * t + (float)1/2 *g * t * t ;
Centigrade =
1.
2.
3.
4.
5.
6.
7.
8.
9.
5( fahrenheit  32)
9
class DataTypes
{
public static void main(String[] arg)
{
double fahrenheit = 42.0;
double centigrade = 5/9*(fahrenheit - 32.0);
System.out.println(centigrade);
}
}
The Fundamental Types
What will happen if you attempt to compile each of the following lines of code?
1.
int x = 25.0;
2.
float x = 1.0;
3.
byte x = 130;
4.
char x = 128;
5.
boolean x = 1;