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 Reference types

Integral types Floating Point

boolean

Integers

byte shortint long float double

User defined classes

Java classes

char

Boolean types

Character

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 bytes0 2,147,483,648 to +2,147,483,647

long 64 bits (8bytes) -9223,372,036,854,775,808 to

+9223,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

long

int

short

byte

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: intint x = 2.0; ^1 errorProcess 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: shortshort x = 150000; ^1 errorProcess 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 precisionfound : intrequired: 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 typesfound : int required: boolean boolean x = 0; ^1 errorProcess 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 -1 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

That is why: 37/5 = 7 , and not 7.4

• The operator ( % ), gives the remainder when applied to division

Hence, 37 % 5 = 2.

2

___________

35

7375

2

___________

35

7375

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 big 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

Class PackingBooks

1. class Packing2. {3. static final int XTRA_LARGE_BOX = 25,4. LARGE_BOX = 15,5. MEDIUM_BOX = 5,6. SMALL_BOX = 1;7.8. int books;9. int big, large, medium, small;10.11. packing(int books)12. {13. this.books = books;14. }

Class PackingBooks – Mutator Method

15.16. void determineBoxes()17. {18. big = 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. }

Class PackingBooks – Mutator Method

27. int getBigBox()28. {29. return big;30. }31.32. int getLargeBox()33. {34. return large;35. }36.37. int getMediumBox()38. {39. return medium;40. }41.42. int getSmallBox()43. {44. return small;45. }46. }

PackingBooks - Constructor

• The problem suggests only one argument required – the number of books

• PackingBooks( books)

Mutator Method

determineBoxes()

Accessor Methods

getBigBox()

getLargeBox()

getMediumBox()

getSmallBox()

PackingBooks

• XS