Abstract Data Types
An Abstract Data Type (ADT) is more a way of looking at a data structure: focusing on what it
does and ignoring how it does its job. A stack or a queue is an example of an ADT. It is important
to understand that both stacks and queues can be implemented using an array. It is also possible
to implement stacks and queues using a linked list. This demonstrates the "abstract" nature of
stacks and queues: how they can be considered separately from their implementation.
To best describe the term Abstract Data Type, it is best to break the term down into
"data type" and then "abstract".
When we consider a primitive type we are actually referring
to two things: a data item with certain characteristics and the permissible operations
on that data. An
int in Java, for example, can contain any whole-number
value from -2,147,483,648 to +2,147,483,647. It can also be used with the operators
+, -, *, and /. The data type's permissible operations are an inseparable part of its
identity; understanding the type means understanding what operations can be performed on it.
In Java, any class represents a data type, in the sense that a class is made up of data
(fields) and permissible operations on that data (methods). By extension, when a data storage
structure like a stack or queue is represented by a class, it too can be referred to as a data type.
A stack is different in many ways from an
int, but they are both defined as a certain
arrangement of data and a set of operations on that data.
Now lets look at the "abstract" portion of the phrase. The word abstract in our context stands
for "considered apart from the detailed specifications or implementation".
In Java, an Abstract Data Type is a class considered without regard to its implementation.
It can be thought of as a "description" of the data in the class and a list of operations
that can be carried out on that data and instructions on how to use these operations. What
is excluded though, is the details of how the methods carry out their tasks. An end user
(or class user), you should be told what methods to call, how to call them, and the results
that should be expected, but not HOW they work.
We can further extend the meaning of the ADT when applying it to data structures such as a
stack and queue. In Java, as with any class, it means the data and the operations that can
be performed on it. In this context, although, even the fundamentals of how the data is
stored should be invisible to the user. Users not only should not know how the methods
work, they should also not know what structures are being used to store the data.
Consider for example the stack class. The end user knows that push() and pop() (amoung
other similar methods) exist and how they work. The user doesn't and shouldn't have to know
how push() and pop() work, or whether data is stored in an array, a linked list, or some
other data structure like a tree.
The ADT specification is often called an interface. It's what the user of the
class actually sees. In Java, this would often be the public methods. Consider for example,
the stack class - the public methods push() and pop() and similar methods from the interface
would be published to the end user.
A Part Of Thiyagaraaj Websites