Data Structures in Java
Mahender K
An abstract data type (ADT) is a type name and a set of operations on that type where:
Users of the ADT are expected to alter/examine values
of this type only via the operations provided. The creator of the ADT promises to leave the operation specifications unchanged. The creator of the ADT is allowed to change the code of the operations at any time, as long as it continues to satisfy the specifications. The creator of the ADT is also allowed to change the data structure actually used to implement the type.
10/2/2009 Data Structures in Java 2
An ADT is not a data type(DT), because it has no representation. We implement an ADT by supplying a representation for the data and algorithms for the operations. So an ADT implementation is a data type. Another way of looking at it:
An ADT is a design concept. A DT is a programming language concept. An ADT implementation is the combination of the
two.
10/2/2009
Data Structures in Java
Lets try an interesting example: Counters.
A counter is simply an object that maintains a
count that can be initialized and incremented.
The first question to ask:
What, precisely, is a counter?
Or, in object-oriented terms:
What is it that makes an object a counter?
10/2/2009
Data Structures in Java
Informally, a counting object
can be initialized, can be incremented, and
can be read.
We can say these things precisely in Java by writing an interface.
10/2/2009
Data Structures in Java
/** Interface for counting objects. */ public interface Countable { /** Increment the internal counter. */ public void inc(); /** Reset the internal counter to 0. */ public void resetCount(); /** Return the internal count. */ public int readCount(); }
10/2/2009
Data Structures in Java
A Java interface is a kind of specification for a class.
It specifies a list of methods that any
implementation must provide.
10/2/2009
Data Structures in Java
/** Simple counting objects. */ public class SimpleCounter implements Countable { /** Initialization for new counters. */ public SimpleCounter () { resetCount(); } /** Reset the counter to 0. */ public void resetCount () { count = 0; } Constructor /** Increment the counter. */ Method public void inc () { count++; } /** Return the current count. */ public int readCount () { return count; } private int count; }
Private instance variable
10/2/2009
Data Structures in Java
/** A program that uses a SimpleCounters.*/ public class Main { public static void main (String args[]) { int n = 99; SimpleCounter c = new SimpleCounter(); SimpleCounter d = new SimpleCounter(); c.inc(); d.inc(); d.inc(); System.out.println (n + c.readCount() + d.readCount()); } Creation of new }
SimpleCounter objects.
10/2/2009
Data Structures in Java
SimpleCounter c = new SimpleCounter();
SimpleCounter d = new SimpleCounter();
10/2/2009
Data Structures in Java
10
Files we have created:
Countable.java The interface specification.
SimpleCounter.java An implementation of the interface.
Main.java A client program.
10/2/2009
Data Structures in Java
11
Strictly speaking, Java does not require us to make use of an interface for this program.
public class SimpleCounter implements Countable { }
10/2/2009
Data Structures in Java
12
Strictly speaking, Java does not require us to make use of an interface for this program.
public class SimpleCounter { } Leaving out the implements declaration is OK with Java.
10/2/2009
Data Structures in Java
13
Interfaces allow us to separate interface from implementation. Clients assume only the interface. Clients thereby protect themselves from many kinds of changes in the underlying implementations.
10/2/2009
Data Structures in Java
14
Separate interface from implementation.
10/2/2009
Data Structures in Java
15
Separate interface from implementation.
10/2/2009
Data Structures in Java
16
Separate interface from implementation. Clients do not need to know most implementation details.
10/2/2009
Data Structures in Java
17
Abstract data types make it much easier to make use of pre-existing code.
We shall see this in later assignments in the
project
work in a team. maintain code in the long run. write down the results of your careful thinking about the problem.
Data Structures in Java 18
10/2/2009
/** Counting objects that double every time. */ public class DoublingCounter implements Countable { /** Initialization for new counters. */ public DoublingCounter () { resetCount(); } /** Reset the counter to 1. */ public void resetCount () { count = 1; }
/** Increment the counter. */ public void inc () { count *= 2; } /** Return the current count. */ public int readCount () { return count; } private int count; }
10/2/2009 Data Structures in Java 19
How to Think Like a Computer Scientist, Downey, Allen B., URL:
Java Structures : Data Structures in Java for the Principled Programmer, Bailey, Duane Structured Computer Organization, Tanenbaum, A. S.,
http://www.cs.williams.edu/JavaStructures/Welcome.html http://www.cs.williams.edu/JavaStructures/Welcome.html ftp://ftp.cs.odu.edu/pub/zeil/cs412/Lectures/03adts/adts_s http://www.greenteapress.com/thinkapjava/
ADTs & Classes, Zeil, Steven J.,
ummary.pdf
Data Structures and Algorithms in Java by Robert Sedge wick
Data Structures in Java 20
10/2/2009
