Abstract Data Types - PowerPoint PPT Presentation


PPT – Abstract Data Types PowerPoint presentation | free to download - id: 157a94-NDFjO


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation

Abstract Data Types


... letters, and its arguments are enclosed in parentheses: toString(), Math.abs(n) ... both ArrayList (fast random access) and LinkedList (fast insertions and ... – PowerPoint PPT presentation

Number of Views:35
Avg rating:3.0/5.0
Slides: 33
Provided by: davidma
Learn more at: http://www.cis.upenn.edu
Tags: abs | abstract | data | fast | types


Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Abstract Data Types

Abstract Data Types
Data types I
  • We type data--classify it into various
    categories--such as int, boolean, String, Applet
  • A data type represents a set of possible values,
    such as ..., -2, -1, 0, 1, 2, ..., or true,
  • By typing our variables, we allow the computer to
    find some of our errors
  • Some operations only make sense when applied to
    certain kinds of data (you cant divide by a
  • Some methods only make sense for certain objects
  • Typing simplifies internal representation
  • A String requires more and different storage than
    a boolean

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
  • boolean
  • char, byte, short, int, long
  • float, double
  • Each primitive type has
  • 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

Primitive types as data types
Classes in Java
  • A class defines 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
  • The operations on the objects are called methods
  • Many classes are defined in Javas packages
  • To program in Java, you can (and must) define
    your own classes, as well as use the ones provided

Methods and operators
  • An operator typically
  • Is written with non-alphabetic characters , ,
    , , , etc.
  • Is written as prefix, infix, or postfix -x, xy,
  • 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 a fixed, predetermined number of arguments

Methods are operators
  • The differences between methods and operations
    are only syntactic differences, not fundamental
  • 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 _at_ to mean
    times 3 plus 1 for example _at_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
  • A list is just a sequence of values
  • There are many ways you could insert a new item
    into a list

As the new first item As the new last item
Before a given item After a given item In
place of a given item
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?

Cognitive load
  • Human minds are limitedyou cant remember
  • You probably dont even remember all the Java
    operators for integers
  • Whats the difference between gtgt and gtgtgt ?
  • What about between ltlt and ltltlt ?
  • We want our operators (and methods) to be useful
    and worth remembering
  • The methods we define should be both necessary
    and sufficient to use the class for its intended
  • Of course, we cant always foresee how the class
    will be used
  • In addition, we typically want some convenience

  • 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
  • Accessing the nth element is efficient for an
    array representation, inefficient for a linked
  • Inserting in the nth position is efficient for
  • Do we want to make it easy for the user to be
  • Do we want the user to have to know the

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?

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

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

Aside 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, you can replace get with
    is (for example, isRunning)
  • This is more than just a conventionif and when
    you start using JavaBeans, it becomes a

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 ?

  • 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

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, and
    also with preserving the flexibility to make
    changes later
  • 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
  • This separation of concerns is essential in any
    large project

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
  • 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
  • If you design for generality, its easy to add
    functionality laterbut removing it may have
    serious consequences

Implementing an ADT
  • To implement an ADT, you need to choose
  • a data representation that
  • must be able to represent all possible values of
    the ADT
  • should be private
  • an algorithm for each of the possible operations
  • must be consistent with the chosen representation
  • all auxiliary (helper) operations that are not in
    the contract should be private

Writing the contract
  • In most cases, the Javadoc for a class is the
  • This means
  • The Javadoc documentation should describe what
    the class is for and how it should be used
  • The Javadoc documentation should not describe
    implementation details
  • Also, now is a good time to read Documentation
    Comments (rules 38 to 58) in The Elements of Java
  • Sometimes, however...
  • The particular implementation makes certain
    operations efficient at the cost of making others
  • For example, Java provides both ArrayList (fast
    random access) and LinkedList (fast insertions
    and deletions)
  • The user needs to know this information, but
    doesnt need detailed implementation information

Contract and implementation in Java,method I
  • Express the contract as an outline class
    declaration, showing only
  • public fields
  • headings of constructors and methods
  • (this is what you would describe in javadoc
  • Express the implementation as a completed class
  • You cant write the outline class declaration
    directly, but Javadoc can create it from your

Contract and implementation in Java,method II
  • Express the contract as an interface
  • Express the implementation as a class that
    implements the interface
  • Disadvantage you cant describe constructors in
    an interface
  • Nevertheless, this is a good technique, and is
    used heavily in Java

Example contract (method I)
  • General description of class
  • public class Die // Each value is a die
    (singular of dice) with n sides, // numbered
    1 to n, with one face showing
  • Constructor
  • public Die(int numberOfSides) //
    constructs a die with faces 1 thru numberOfSides
  • Accessor
  • int lastRoll() // returns the
    result of the previous roll
  • Transformer (mutative)
  • int roll() // returns the result
    of a new roll of the die

Implementation, method I, 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!

Implementation, method I, page 2
  • int lastRoll() return face
  • int roll() face
    random.nextInt(numberOfSides) 1 return
  • // class Die

Contract, method II
  • interface DieRoller
  • int lastRoll()
  • int roll()
  • Notice
  • There is no way to define a constructor
  • However, this should be part of the contract!
  • We need two names one for the interface, and one
    for the class that implements it
  • Usually more than one class will implement an

Implementation, method II
  • import java.util.
  • public class Die implements DieRoller
  • // Everything else is the same
  • Frequently more than one class will implement an
  • The interface describes the general (more
    abstract) case
  • Implementations are designed for specific classes

  • A class is responsible for its own values
  • It should protect them from careless or malicious
  • Ideally, a class should be written to be
    generally useful
  • 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
  • They werent written specifically for your
  • Strive to make your classes more like Javas!

Aside an interesting bug
  • Originally, I left the word static out ofprivate
    static Random random
    new Random()
  • Then I created a Vector of ten dice (Dies)
  • When I printed the Vector, I got 2 2 2
    2 2 2 2 2 2 2
  • Why?
  • These really were ten different Die objects
  • Hint How does Java initialize its random number

  • 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

The End
About PowerShow.com