Comp 302: Software Engineering

Data Abstractions

Data Abstraction

data abstraction = <objects,operations>

Why data abstractions?

When the implementation of the abstraction changes, programs that use it don’t have to change.

Only access the object through methods it provides Can avoid making implementation decisions too early

Avoid inefficiencies and massive re-implementation Can first define the abstract type with its operations

Can then work on using modules Make implementation decisions later

Outline

How to specify data abstractions? How to implement data abstractions?

Specifications for Data Abstractions

visibility class dname {// OVERVİEW: A brief description of the

// behaviour of the type’s objects goes here//constructors//specs for constructors go here

//methods//specs for methods go here

}

Specification of IntSet (code filled in later)public class IntSet {

//OVERVİEW: IntSets are mutable, unbounded sets of integers//A typical IntSet is {x1,...,xn}.

//constructorspublic IntSet ( )

//EFFECTS: Initialize this to be empty. (no need for MODIFIES clause)

//methodspublic void insert (int x)

// MODIFIES: this// EFFECTS: Adds x to the element of this, // i.e., this_post = this + {x}

public void remove (int x)// MODIFIES: this// EFFECTS: Removes x from this, i.e., this_post = this – {x}

public boolean isIn (int x)// EFFECTS: If x is in this returns true else returns false

public int size ()// EFFECTS: Returns the cordinality of this

public int choose () throws EmptyException// EFFECTS: If this is empty, throws EmptyException

// else returns an arbitrary element of this.}

mutators

observers

Mutability States of immutable objects never change

They are created and they stay that way until destroyed Example: Strings Huh? What about

String myFirstName = “Serdar”;String myLastName = “Tasiran”;String myFullName = myFirstName + “ “ + myLastName;

A new String object is created. The String with “Serdar” in it is never changed.

Mutable objects: Example: Arrays. a[i] = 5; If a mutable object is shared, a modification of one modifies the other.

public class Poly {//OVERVIEW: Polys are immutable polynomials with integer coefficients.//A typical Poly is c0 + c1x + c2x2 + ... + cnxn

//constructorspublic Poly ()

//EFFECTS: Initializes this to be zero polynomial

public Poly (int c, int n) throws NegativeExponentException// EFFECTS: If n<0 throws NegativeExponentException else initalizes this

// to be the Poly cxn.

//methodspublic int degree ()

// EFFECTS: Returns the degree of this, i.e., the largest exponent with a // non-zero coefficient. Returns 0 if this is zero Poly.

public int coeff (int d)// EFFECTS: Returns the coefficient of the term of this whose exponent is

// d.

public Poly add (Poly q) throws NullPointerException// EFFECTS: If q is null throws NullPointerException else returns the Poly

// this +q.

public Poly mul (Poly q) throws NullPointerException// EFFECTS: If q is null throws NullPointerException else returns the Poly

// *q.

public Poly sub (Poly q) Throws NullPointerException// EFFECTS: If q is null throws NullPointerException else returns the Poly

// this –q.

public Poly minus ()//EFFECTS: Returns the Poly – this.

}

Design Issues: Mutability When to make a data type mutable, when not to. Type should be immutable when its elements would naturally

have unchanging values We’ll talk more on this later, but in general, when modeling real-

world objects, types should be mutable Mostly mathematical or other symbolic objects are not mutable.

This allows more sharing of subparts

Immutable: Safe, but may be inefficient Create and discard many intermediate objects before

completing computation Lots of garbage collection

Mutable: Less garbage collection, less safe.

Using Data Abstractionspublic static Poly diff (Poly p) throws NullPointerExcepyion {

//EFFECTS: If p is null throws NullPointerException //else returns the Poly obtained by differentiating

p.Poly q = new Poly ();for (int i = 1; i <= p.degree(); i++)

q = q.add(new Poly(p.coeff(i)*i, i - 1));return q;

}

public static IntSet getElements (int[] a)throws NullPointerException {

//EFFECTS: If a is null throws NullPointerException //else returns a set containing an entry for each //distinct element of a.IntSet s = new IntSet();for (int i = 0; ,< a.length; i++) s.insert(a[i]);return s;

}

Implementing Data Abstractions Must select a representation (rep).

Examples: A Vector (from java.util) of Integer objects is a possible

rep for IntSet Reps must

Support all operations in a simple way Provide efficient implementations

Searching an entry should not require looking at all entries, ideally.

A Rep for IntSet

Should we allow each element to occur more than once or not If we do, insertion is simple: Just add it at the end

of the Vector But remove and isIn take a long time

isIn is likely to be called a lot Forbid duplicates in Vector

Implementing Data Abstractions A representation typically has several components

Correspond to (non-static) fields in the class definitions These are also called instance variables

There is a separate set of them for each object

Use static fields to store information that applies to all objects of that class Example: The number of instances created.

Instance variables must not be visible to users, other classes Make them private Provide methods to access and modify them

public class IntSet {//OVERVIEW: IntSets are unbounded, mutable sets of integers.

private Vector els; // the rep

//constructors

public IntSet () {//EFFECTS: Initializes this to be emptyels = new Vector(); }

//methods

public void insert (int x) {//MODIFIES: this//EFFECTS: Adds x to the elements of this.Integer y = new Integer(x);if (getIndex(y) < 0) els.add(y); }

public void remove (int x) {//MODIFIES: this//EFFECTS: Removes x from this.int i = getIndex(new Integer(x));if (i < 0) return;els.set(i, els.lastElement());els.remove(els.size() - 1); }

public boolean isIn (int x) {//EFFECTS: Returns true if x is in this else returns false.return getIndex(new Integer(x)) }

(Continued)

private int getIndex (Integer x) {//EFFECTS: If x is in this returns index

where //x appears else returns -1.for (int i = 0; i < els.size(); i++)

if (x.equals(els.get(i))) return i;return -1; }

public int size () {//EFFECTS: Returns the cardinality of this.return els.size(); }

public int choose () throws EmptyException {//EFFECTS: If this is empty throws EmptyException

else //returns an arbitrary element of this.if(els.size() == 0) throw new

EmptyException(“IntSet.choose”);return els.lastElement(); }

}

public class Poly {

//OVERVIEW: ...private int[] trms;private int deg;

//constructorspublic Poly () {

//EFFECTS: Initilizes this to be the zero polynomial.

trms = new int[1]; deg = 0; }

public Poly (int c, int n) throws NegativeExponentException {

//EFFECTS: If n < 0 throws NegativeExponentException // else initializes this to be the Poly cxn.

if (n < 0) throw new NegativeExponentException(“Poly(int,int) constructor”); if (c == 0) { trms = new int[n+1]; deg = n; } trms = new int [n+1]; for (int i = 0; i < n; i++) trms[i] = 0; trms[n] = c; deg = n; }

private Poly (int n) { trms = new int[n+1]; deg = n; }//methods

public int degree () { // EFFECTS: Returns the degree of this, i.e.,

// the largest exponent with a non-zero coefficient. // Returns 0 if this is the zero Poly.

return deg; }

public int coeff (int d) { // EFFETCS: Returns the coefficient of the

// term of this whose exponent is d.

if (d < 0 || d > deg) return 0; elsereturn trms[d]; }

public Poly sub (Poly q) throws NullPointerException { // EFFECTS: If q is null throws // NullPointerException else returns add (q.minus()); }

public Poly minus () { //EFFECTS: Returns the Poly –this.

Poly r = new Poly(deg); for (int i = 0; i < deg; i++) r.trms[i] = - trms[i]; return r; }

public Poly add (Poly q) throws NullPointerException {

// EFFECTS: If q is null throws NullPointerException // else returns this +q.

Poly la, sm;

if (deg < q.deg) {la = this; sm = q;} else {la = q; sm = this;}

int newdeg = la.deg; //new degree is the larger degree

if (deg == q.deg) //unless there are trailing zeros

for (int k = deg; k > 0; k--) if (trms[k] + q.trms[k] != 0) break; else newdeg--;

Poly r = new Poly(newdeg); //get a new Polyint i;for (i = 0; i <= sm.deg && i <=newdeg; i++)

r.trms[i] = sm.trms[i] + la.trms[i];for (int j = i; j <= newdeg; j++) r.trms[j] = la.trms[j];return r;

}

public Poly mul (Poly q) throws NullPointerException {// EFFECTS: If q is null throws NullPointerException

// else returns the Poly this *q.

if ((q.deg == 0 && q.trms[0] == 0) || (deg == 0 && trms[0] == 0))

return new Poly();

Poly r = new Poly(deg+q.deg);r.trms[deg+q.deg] = 0; //prepare to compute coeffs

for (int i = 0; i <= deg; i++) for (int j = 0; j <= q.deg; j++)

r.trms[i+j] = r.trms[i+j] + trms[i] * q.trms[j];return r;

}

Implementation Decisions Suppose our array is sparse

2x1001 – x2 + 3x – 1 We would have an array with 999 zeros

Very inefficient

Alternative Store only non-zero coefficients and their associated exponents private Vector coeffs;

private Vector exps; Problem: Must keep the two vectors lined up. Better to have one Vector, with “records” representing (coeff, exp) pairs.

class Pair {//OVERVIEW: A record typeint coeff;int exp;Pair(int c, int n) { coeff = c; exp = n; }

} // No spec needed: Package accessible fields.

RecordsInstead of

public int coeff (int x) {for (int i = 0; i < exps.size(); i++)

if (((Integer) exps.get(i)).intValue() == x)return ((Integer)

coeff.get(i)).intValue();return 0; }

We now have

private Vector trms; // the terms with non zero coefficientspublic int coeff (int x) {

for (int i = 0; i < trms.size(); i++) {Pair p = (Pair) trms.get(i);if (p.exp == x) return p.coeff; }

return 0; }

Methods Inherited from Object All classes are subclasses of Object They

either provide implementations for all of Object’s methods equals, clone, toString, …

or inherit Object’s version of these methods

Two objects should be equals if they are behaviorally equivalent, i.e., cannot distinguish them using the object’s own methods

Distinct mutable objects are always distinguishableIntSet s = new IntSet();IntSet t = new IntSet();if (s.equals(t)) ...; else ...

cloneing Makes a copy of its object

The copy should have the same state

Object defines a default implementation Creates a new object of the same type, copies each instance field

Often not correct for the object we’re dealing with For IntSet, the two copies would share the els Vector. If one is modified, the other will be also Must generate independent copy

For immutable objects, it is OK to share fields Fields never get changed

In general, immutable objects should inherit from Object, mutable ones should provide their own implementation.

Usage: visibility class Classname implements Cloneable { }

public class Poly implements Cloneable {//as given before, plus

public boolean equals (Poly q) {if (q == null || deg != q.trms.length) return

false;for (int i = 0; i <= deg; i++)

if (trms[i] != q.trms[i]) return false;return true; }

public boolean equals (Object z) {if(!(z instanceof Poly)) return false;return equals((Poly) z); }

}

public class IntSet {//as given before, plusprivate IntSet (Vector v) { els = v; }

public Object clone () {return new IntSet((Vector) els.clone()); }

}

If you invoke clone() on an object that doesn’t implement Cloneable, the clone() method inherited from Object throws the CloneNotSupportedException.

Typecasting Clones

IntSet t = (IntSet) s.clone();

The toString method toString() returns a String that represents the state of the object. The default method provided by Object prints the type name and hash code.

Not very useful Must provide our own toString() implementation Examples:

IntSet: {1, 7, 3}Poly: 2 + 3x + 5x^2

IntSet implementation:

public String toString () {if (els.size() == 0) return “IntSet:{}”;String s = “IntSet: {“ els.elementAt(0).toString();for (int i = 1; i < els.size(); i++)

s = s + “ , “ + els.elementAt(i).toString();return s + “}”; }

Unknowingly Exposing the Rep: BAD!!!public Vector allEls()

//EFFECTS: Returns a vector containing the //elements of this, each exactly once, in //arbitrary order{

return els; }

public IntSet (Vector elms) throws NullPointerException // EFFECTS: If elms is null throws // NullPointerException else initializes this to // contain as elements all the ints in elms.

{if (elms == null)

throw new NullPointerException(“IntSet 1 argument constructor”);

els = elms;}

Operation Categories Creators:

Create an object from scratch A constructor with no arguments

Producers: Take object(s) of your own type Generate a new one Examples: Constructors with arguments of same type, mul method

of Poly (returns Poly) Mutators:

Modifies objects of its type : insert, delete for IntSet

Observers: Reports something about its current state

Adequacy Provide enough operations

Everything that the user of your class wants can be done Simply: a few method calls at most Efficiently: doesn’t take a long time to complete

Type must be fully populated Must be possible to obtain all possible abstract states using

methods Example: Must be able to get any IntSet

But don’t provide too many operations Complicated to understand Difficult to maintain

If rep changes, you have to fix a lot of methods