Abstract Data Types

Sep 1, 2015

Data types I

We type data--classify it into various categories-such as int, boolean, String, Applet

By typing our variables, we allow the computer to

find some of our errors

A data type represents a set of possible values, such as

{..., -2, -1, 0, 1, 2, ...}, or {true, false}

Some operations only make sense when applied to

certain kinds of data--multiplication, searching

Typing simplifies internal representation

A String requires more and different storage than a

boolean
2

Data types II

A data type is characterized by:

a set of values
a data representation, which is common to all these
values, and
a set of operations, which can be applied uniformly to
all these values

Primitive types in Java

Java provides eight primitive types:

Each primitive type has

boolean
char, byte, short, int, long
float, double
a set of values
a data representation
a set of operations

These are set in stonethere is nothing the

programmer can do to change anything about them
4

Primitive types as data types

Type

Values

Representation Operations

boolean

true, false

Single byte

&&, ||, !

Twos complement

+, -, *, /,
others

Floating point Twos complement

numbers of
with exponent and
varying sizes mantissa
and precisions

+, -, *, /,
others

char, byte, Integers of

short, int, varying sizes
long
float,
double

Classes in Java

A class is a data type

The possible values of a class are called objects

The data representation is a reference (pointer) to a block
of storage

The structure of this block is defined by the fields (both inherited

and immediate) of the class

The operations on the objects are called methods

Many classes are defined in Javas packages

You can (and must) define your own, as well

Methods and operators

An operator typically

Is written with non-alphabetic characters: +, *, ++,

+=, &&, etc.
Is written as prefix, infix, or postfix: -x, x+y, x++
Has only one or two arguments, or operands

A method (or function) typically

Is written with letters, and its arguments are enclosed in

parentheses: toString(), Math.abs(n)
Has any (predetermined) number of arguments

Methods are operators

The differences between methods and operations are only

syntactic differences, not fundamental ones
Many languages (not including Java) let you define new
operators, that is, new syntax
When you define a new class and its methods, you are,
fundamentally, defining a new data type and its operators
Suppose a language defines the operator @ to mean times 3
plus 1; for example @7 is 22

Would you consider this a good operation to have in the language?

What does this suggest about defining classes and their methods?

Insertion into a list

There are many ways you could insert a new node into a list:
As the new first element
As the new last element
Before a given node
After a given node
Before a given value
After a given value

Before the nth element

After the nth element
Before the nth from the end
After the nth from the end
In the correct location to keep
the list in sorted order

Is it a good idea to supply all of these?

If not, why not?
9

Cognitive load

Human minds are limitedyou cant remember

everything

You probably dont even remember all the Java operators for integers

Whats the difference between >> and >>> ?

What about between << and <<< ?

We want our operators (and methods) to be useful and

worth remembering

10

Efficiency

A list is just a sequence of valuesit could be

implemented by a linked list or by an array

Inserting as a new first element is efficient for a linked

list representation, inefficient for an array
Accessing the nth element is efficient for an array
representation, inefficient for a linked list
Inserting in the nth position is efficient for neither

Do we want to make it easy for the user to be

inefficient?
Do we want the user to have to know the
implementation?
11

Abstract Data Types

An Abstract Data Type (ADT) is:

a set of values
a set of operations, which can be applied uniformly to all
these values

To abstract is to leave out information, keeping

(hopefully) the more important parts

What part of a Data Type does an ADT leave out?

12

Data Structures

Many kinds of data consist of multiple parts, organized

(structured) in some way
A data structure is simply some way of organizing a value
that consists of multiple parts

Hence, an array is a data structure, but an integer is not

When we talk about data structures, we are talking about the

implementation of a data type
If I talk about the possible values of, say, complex numbers,
and the operations I can perform with them, I am talking about
them as an ADT
If I talk about the way the parts (real and imaginary) of a
complex number are stored in memory, I am talking about a
data structure
An ADT may be implemented in several different ways

A complex number might be stored as two separate doubles, or as an

array of two doubles, or even in some bizarre way

13

Data representation in an ADT

An ADT must obviously have some kind of

representation for its data

The user need not know the representation

The user should not be allowed to tamper with the
representation
Solution: Make all data private

But what if its really more convenient for the user

to have direct access to the data?

Solution: Use setters and getters

14

Example of setters and getters

class Pair {
private int first, last;
public getFirst() { return first; }
public setFirst(int first) { this.first = first; }
public getLast() { return last; }
public setLast(int last) { this.last = last; }

15

Naming setters and getters

Setters and getters should be named by:

Capitalizing the first letter of the variable (first becomes

First), and
Prefixing the name with get or set (setFirst)
For boolean variables, replace get with is (for example,
isRunning)

This is more than just a conventionif and when you

start using JavaBeans, it becomes a requirement

16

Whats the point?

Setters and getters allow you to keep control of your

implementation
For example, you decide to define a Point in a plane by its x-y
coordinates:
class Point { public int x; public int y; }
Later on, as you gradually add methods to this class, you decide
that its more efficient to represent a point by its angle and
distance from the origin, and
Sorry, you cant do thatyoull break too much code that
accesses x and y directly
If you had used setters and getters, you could redefine them to
compute x and y from and
17

Contracts

Every ADT should have a contract (or

specification) that:

Specifies the set of valid values of the ADT

Specifies, for each operation of the ADT:

Its name
Its parameter types
Its result type, if any
Its observable behavior

Does not specify:

The data representation

The algorithms used to implement the operations

18

Importance of the contract

A contract is an agreement between two parties; in this

case

The implementer of the ADT, who is concerned with making

the operations correct and efficient
The applications programmer, who just wants to use the ADT
to get a job done

It doesnt matter if you are both of these parties; the

contract is still essential for good code
This separation of concerns is essential in any large
project
19

Promise no more than necessary

For a general API, the implementer should provide as

much generality as feasible
But for a specific program, the class author should
provide only what is essential at the moment

In Extreme Programming terms, You aint gonna need it!

In fact, XP practice is to remove functionality that isnt
currently needed!
Your documentation should not expose anything that the
application programmer does not need to know

If you design for generality, its easy to add

functionality laterbut removing it may have serious
consequences
20

Implementing an ADT

To implement an ADT, you need to choose:

a data representation

an algorithm for each of the necessary operations

must be able to represent all necessary values of the ADT

should be private
must be consistent with the chosen representation
all auxiliary (helper) operations that are not in the contract should
be private

Remember: Once other people (or other classes) are

using your class:

Its easy to add functionality

You can only remove functionality if no one is using it!
21

Example contract (Javadoc)

General description of class

/**
* Each value is a die (singular of dice) with n sides,
* numbered 1 to n, with one face showing.
*/
public class Die

Constructor

/**
* Constructs a die with faces numbered 1 thru numberOfSides.
*/
public Die(int numberOfSides)

Accessor

/**
* Returns the result of the previous roll.
*/
int lastRoll()

Transformer (mutative)

/**
* Returns the result of a new roll of the die.
*/
int roll()

22

Implementation, page 1
import java.util.*;
public class Die {
private int numberOfSides;
private static Random random = new Random();
private int face;
public Die(int numberOfSides) {
this.numberOfSides = numberOfSides;
face = roll(); // construct in a valid state!
}
23

Implementation, page 2
int lastRoll() {
return face;
}
int roll() {
face = random.nextInt(numberOfSides) + 1;
return face;
}
} // class Die

24

Responsibilities

A class is responsible for its own values

Ideally, a class should be written to be generally

useful

It should protect them from careless or malicious users

The goal is to make the class reusable

The class should not be responsible for anything
specific to the application in which it is used

In practice, most classes are application-specific

Javas classes are, on the whole, extremely well
designed

They werent written specifically for your program

Strive to make your classes more like Javas!

25

Aside: an interesting bug

Originally, I left the word static out of

private static Random random = new Random();

Then I created a Vector of ten dice (Dies)

When I printed the Vector, I got:
2

Why?

These really were ten different Die objects

Hint: How does Java initialize its random number

generator?
26

Summary

A Data Type describes values, representations, and

operations
An Abstract Data Type describes values and
operations, but not representations

An ADT should protect its data and keep it valid

All, or nearly all, data should be private
Access to data should be via getters and setters
An ADT should provide:
A contract
A necessary and sufficient set of operations
27

The End

28