Chapter 1 Object-Oriented Programming Using Java

Data Structures and Algorithms in Java

Objectives
Discuss the following topics: Rudimentary Java Object-Oriented Programming (OOP) in Java Input and Output Java and Pointers Vectors in java.util Data Structures and Object-Oriented Programming Case Study: Random Access File
Data Structures and Algorithms in Java 2

Rudimentary Java
A Java program is a sequence of statements that have to be formed in accordance with the predefined syntax A statement is the smallest executable unit in Java Each statement ends with a semicolon Compound statements, or blocks, are marked by delimiting them with braces, { and }

Data Structures and Algorithms in Java

Variable Declarations
Each variable must be declared before it can be used in a program It is declared by specifying its type and its name Variable names are strings of any length of letters, digits, underscores, and dollar signs that begin with a letter, underscore, or dollar sign A letter is any Unicode letter Java is case sensitive
Data Structures and Algorithms in Java 4

Variable Declarations (continued)

A type of variable is either:
One of the eight built-in basic types A built-in or user-defined class type An array

Data Structures and Algorithms in Java

Variable Declarations (continued)

Table 1-1 Variable built-in types and their sizes
Type
boolean char byte short int long float double

Size
1 bit 16 bits 8 bits 16 bits 32 bits 64 bits 32 bits 64 bits

Range
true, false Unicode characters [-128, 127] [-32768, 32767] [-2147483648, 2147483647] [-9223372036854775808, 9223372036854775807] [-3.4E38, 3.4E38] [-1.7E308, 1.7E308]

Data Structures and Algorithms in Java

Operators
Value assignments are executed with the assignment operator = Use one at a time or string together with other assignment operators x = y = z = 1; For a prefix operator, a variable is incremented (or decremented) first and then an operation is performed in which the increment takes place For a postfix operator, autoincrement (or autodecrement) is the last operation performed
Data Structures and Algorithms in Java 7

Decision Statements
One decision statement is an if-else statement
if (condition) do something; [else do something else;]

A switch statement is shorthand for nested if statements

switch (integer expression) { case value1: block1; break; . . . . . . case valueN: blockN; break; default: default block; }
Data Structures and Algorithms in Java 8

Loops
The first loop available in Java is the while loop:
while (condition) do something;

The second loop is a do-while loop:

do do something; while (condition);

The third loop is the for loop:

for (initialization; condition; increment) do something;
Data Structures and Algorithms in Java 9

Exception Handling
Catching an error is possible by using the try-catch statement
try { do something; } catch (exception-type exception-name) { do something; }

The number of catch clauses is not limited to one

Data Structures and Algorithms in Java

10

Object-Oriented Programming (OOP) in Java

A class is a template in accordance to which objects are created Functions defined in a class are called methods Variables used in a class are called class scope variables, data fields, or fields The combination of data and related operations is called data encapsulation An object is an instance of a class, an entity created using a class definition
Data Structures and Algorithms in Java 11

Encapsulation
Objects make the connection between data and methods much tighter and more meaningful The first OOL was Simula; it was developed in the 1960s in Norway The information-hiding principle refers to objects that conceal certain details of their operations from other objects so that these operations may not be adversely affected by other objects
Data Structures and Algorithms in Java 12

Class Methods and Class Variables

Static methods and variables are associated with the class itself and are called class methods and class variables Nonstatic variables and methods are called instance variables and instance methods The method main() must be declared as static

Data Structures and Algorithms in Java

13

Generic Classes
class IntClass { int[] storage = new int[50]; .................. } class DoubleClass { double[] storage = new double[50]; .................. } class GenClass { Object[] storage = new Object[50]; Object find(int n) { return storage[n]; } .................. }
Data Structures and Algorithms in Java 14

Arrays
Arrays are Java objects There is no keyword with which all arrays are declared Without keywords, subclasses cannot be created Arrays are declared with empty brackets after the name of the type or the name of the array itself

Data Structures and Algorithms in Java

15

Arrays (continued)
These two declarations are equivalent:
int[] a;
and

int a[];

A declaration of a basic data type also creates an item of the specified type Wrapper classes provide object versions of basic data types

Data Structures and Algorithms in Java

16

Abstract Data Types

An item specified in terms of operations is called an abstract data type In Java, an abstract data type can be part of a program in the form of an interface Interfaces are similar to classes, but can contain only:
Constants (final variables) Specifications of method names, types of parameters, and types of return values
Data Structures and Algorithms in Java 17

Abstract Data Types (continued)

interface I { void If1(int n); final int m = 10; } class A implements I { public void If1(int n) { System.out.println("AIf1 " + n*m); } } abstract class AC { abstract void ACf1(int n); void ACf2(int n) { System.out.println("ACf2 " + n); } } class B extends AC { public void ACf1(int n) { System.out.println("BACf1 " + n); } } Data Structures and Algorithms in Java 18

Inheritance
OOLs allow for creating a hierarchy of classes so that objects do not have to be instantiations of a single class Subclasses or derived classes inherit the fields and methods from their base class so that they do not have to repeat the same definitions A derived class can override the definition of a non-final method by introducing its own definition
Data Structures and Algorithms in Java 19

Polymorphism
Polymorphism is the ability of acquiring many forms Dynamic binding is when the type of method to be executed can be delayed until run time Static binding is when the type of response is determined at compilation time Dynamic binding is when the system checks dynamically the type of object to which a variable is currently referring and chooses the method appropriate for this type
Data Structures and Algorithms in Java 20

Polymorphism (continued)
class A { public void process() { System.out.println("Inside A"); } } class ExtA extends A { public void process() { System.out.println("Inside ExtA"); } }

Data Structures and Algorithms in Java

21

Polymorphism (continued)
then the code A object = new A(); object.process(); object = new ExtA(); object.process(); results in the output Inside A Inside ExtA
Data Structures and Algorithms in Java 22

Input and Output

To use the classes for reading and writing data, the java.io package has to include the statement:
import java.io.*;

To print anything on the screen, use the statements: System.out.print(message); System.out.println(message); To read one line at a time, the method readLine() from BufferedReader is used
Data Structures and Algorithms in Java 23

Reading Tokens: Words and Numbers

The nextToken() method skips space characters separating tokens and updates the tokenizers instance variables:
sval of type String, which contains the current token when it is a word nval of type double, which contains the current token when it is a number ttype of type int, which contains the type of the current token
Data Structures and Algorithms in Java 24

Reading Tokens: Words and Numbers (continued)

There are four types of tokens:
TT_EOF (end of file) TT_EOL (end of line) TT_WORD TT_NUMBER

Data Structures and Algorithms in Java

25

Reading Tokens: Words and Numbers (continued)

void readTokens(String fInName) throws IOException { StreamTokenizer fIn = new StreamTokenizer( new BufferedReader( new FileReader(fInName))); fIn.nextToken(); String s; while (fIn.ttype != StreamTokenizer.TT_EOF) { if (fIn.ttype == StreamTokenizer.TT_WORD) s = "word"; else if (fIn.ttype == StreamTokenizer.TT_NUMBER) s = "number"; else s = "other"; System.out.println(s + ":\t" + fIn); fIn.nextToken(); } }
Data Structures and Algorithms in Java 26

Reading and Writing Primitive Data Types

The DataInputStream class provides methods for reading primitive data types in binary format The methods include:
readBoolean() readByte() readShort() readChar() readInt() readLong() readUTF() (to read strings in Unicode Text Format)
27

Data Structures and Algorithms in Java

Reading and Writing Objects

Objects can be saved in a file if they are made persistent An object becomes persistent if its class type is stated to implement the Serializable interface

Data Structures and Algorithms in Java

28

Reading and Writing Objects (continued)

class C implements Serializable { int i; char ch; C(int j, char c) { i = j; ch = c; } public String toString() { return "("+ i + " " + ch +")"; } }

Data Structures and Algorithms in Java

29

Random Access Files

To be able to both read and write in the same file at any position in the file, a random access file should be used A file is created with the constructor:
RandomAccessFile(name, mode);

The constructor opens a file with the specified name either for reading, or for reading and writing:
RandomAccessFile = raf new RandomAccessFile("myFile", "rw");
Data Structures and Algorithms in Java 30

Random Access Files (continued)

The method length() returns the size of the file measured in bytes The method getFilePointer() returns the current position in the file The method seek(pos) moves the file pointer to the position specified by an integer pos

Data Structures and Algorithms in Java

31

Random Access Files (continued)

Reading is done by:
read(), which returns a byte as an integer read(b), which fills entirely a byte array b read(b,off,len), which fills len cells of the byte array b starting from cell off readLine(), which reads one line of input

Data Structures and Algorithms in Java

32

Java and Pointers

Although Java does not use explicit pointers, object access is implemented in terms of pointers In many languages, pointer is a technical term for a type of variable; in Java, the term reference is used instead

Data Structures and Algorithms in Java

33

Java and Pointers (continued)

Figure 1-1 Object reference variables p and q (a) logic of reference of q to an object (b) implementation of this reference

Data Structures and Algorithms in Java

34

Java and Pointers (continued)

Figure 1-2 Illustrating the necessity of using the method clone()

Data Structures and Algorithms in Java 35

Vectors in java.util
A vector is a data structure with a contiguous block of memory, just like an array Class Vector is a flexible array whose size can be dynamically changed The class hierarchy in the package java.util is:
Object AbstractCollection AbstractList Vector

Data Structures and Algorithms in Java

36

Vectors in java.util (continued)

The status of the vector can be tested with two methods:
size(), which returns the number of elements currently in the vector capacity(), which returns the number of cells in the vector

If the vectors capacity is greater than its size, then a new element can be inserted at the end of the vector immediately
Data Structures and Algorithms in Java 37

Vectors in java.util (continued)

The method trimToSize() should be used to reduce wasted space The method ensureCapacity() should be used to set the maximum number of elements inserted in a vector The method ensureCapacity() affects only the capacity of the vector, not its content The method setSize() affects its content and possibly the capacity
Data Structures and Algorithms in Java 38

Vectors in java.util (continued)

The method addElement() adds an element at the end of the vector The insertion of an element in any other position can be performed with the method insertElementAt() The method elements() puts vector elements in an object of Enumeration type The method clone() clones the array implementing the vector, but not the objects in the array
Data Structures and Algorithms in Java 39

More Research
Tutorial: http://java.sun.com/docs/books/tutorial/java/index.html . Hierachy for packages and classes: http://java.sun.com/j2se/1.4.2/docs/api/overviewtree.html

Data Structures and Algorithms in Java

40

Data Structures and Object-Oriented Programming

The data structures field is designed for:
Building tools to be incorporated in and used by programs Finding data structures that can perform certain operations speedily without imposing too much burden on computer memory Building classes by concentrating on the mechanics of these classes Investigating the operability of these classes by modifying the data structures to be found inside the classes
Data Structures and Algorithms in Java 41

Case Study: Random Access File

Write a generic program that generates a random access file for any type of record Each record consists of five personal fields: a Social Security number, name, city, year of birth, and salary And a student file that consists of the personal fields and academic major

Data Structures and Algorithms in Java

42

Summary
A Java program is a sequence of statements that have to be formed in accordance with the predefined syntax. A statement is the smallest executable unit in Java. Compound statements, or blocks, are marked by delimiting them with braces, { and }. A class is a template in accordance to which objects are created.
Data Structures and Algorithms in Java 43

Summary (continued)
Functions defined in a class are called methods. Variables used in a class are called class scope variables, data fields, or fields. The combination of data and related operations is called data encapsulation. An object is an instance of a class, an entity created using a class definition. An item specified in terms of operations is called an abstract data type.
Data Structures and Algorithms in Java 44

Summary (continued)
Subclasses, or derived classes, inherit the fields and methods from their base class so that they do not have to repeat the same definitions. Polymorphism is the ability of acquiring many forms. In many languages, pointer is a technical term for a type of variable; in Java, the term reference is used instead. A vector is a data structure with a contiguous block of memory, just like an array.
Data Structures and Algorithms in Java 45