Data Structures and Algorithms in Java

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
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 }
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
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
Variable Declarations (continued)

Table 1-1 Variable built-in types and their sizes
Type
Size
Range
boolean
1 bit
true, false
char
16 bits
Unicode characters
byte
8 bits
[-128, 127]
short
16 bits
[-32768, 32767]
int
32 bits
[-2147483648, 2147483647]
long
64 bits
[-9223372036854775808, 9223372036854775807]
float
32 bits
[-3.4E38, 3.4E38]
double
64 bits
[-1.7E308, 1.7E308]
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
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;
}
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;
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
10
(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
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
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
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];
}
..................
}
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
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
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
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);
}
}
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
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
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");
}
}
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
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
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
24

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

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();
}
}
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
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
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 +")";
}
}
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");
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
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
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
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
34
Java and Pointers (continued)
Figure 1-2 Illustrating the necessity of using the method clone()

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

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
38

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
39
Data Structures and

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
40
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
41
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.
42
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.
43
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.
44

Data Structures and Algorithms in Java

Uploaded by

Copyright:

Available Formats

Data Structures and Algorithms in Java

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Data Structures and Algorithms in Java

Uploaded by

Copyright:

Available Formats

Chapter 1