What is a list?

• A collection of items (Arrays are an example):
  • Indexed in order from 0 to n-1
  • Can add things to the list, remove things, find things, etc.
• In order to use, programmer doesn't need to know how the list is implemented
• Several different implementations
  • Each has strengths / weaknesses
  • Need to understand inner workings to pick best type of list

What is an ADT?

• An abstract data type is:
  • A high-level description of a data structure
  • A description of the methods and what they do
• Does not include:
  • Specifics about HOW that structure is implemented (but usually in API if you read closely)
  • Specifics about efficiency of methods
• List is our first ADT

What is an Interface?

• Notice that when describing a List, we know some the operations:
  • insert element at end of list
  • insert at specific index of list
  • get element at specific index of list
  • find element in the list
• But we DO NOT describe how these are accomplished
  • Java allows you to describe this using interfaces

Example Java Interface: List

/* Abstraction of a list that holds double values */
public interface List{

  /* Methods are NOT implemented, they are abstract */
  /* A class that is a list MUST have these methods */

  /* inserts value into this list at the end */
  public void insert(double value);

  /* inserts at the specified index */
  public void insert(double value, int index);

  /* finds the value and removes it from the list */
  public void remove(double value);

  /* finds the value and returns its index, if present */
  public int find(double value);

  /* overwrites the item at a specified index */
  public void setAt(int index, double value);

  /* returns the item at specified index */
  public double getAt(int index);
}

Java List API

• Note that java already has a List Interface
  • You can (and should) check that out on your own time.

Implementation of an actual List

/* A class that IS a list */
//implements keywork means this object is a list
//and thus MUST contain and implement all of the methods
//in the List interface
public class Vector implements List{

  private double[] theList;

  public void insert(double value){
    /* This class will actually implement this */
    /* and actually do the inserting*/
  }

  public int find(double value){
    for(int i = 0; i < theList.length; i++){
      if(theList[i] == value) return i;
    }
    return -1; //didn't find it
  }

  /* Other list methods would be implemented below */
}

Why use interfaces?

• What benefit do we get?
  • the primary benefit is polymorphism
• Polymorphism is a feature of object oriented languages (like Java) in which type substitutions can be made at runtime.
• For example, if we want to write code to sort lists, why write a sorting method for each type of list.
  • Would be better if we had a generic sorting method for ALL lists
  • Than, anything that IS a list is sorted the exact same way.

Polymorphism Example

public class SortingMethods{

  public static void sort(List theList){
    /* CODE TO SORT LIST IS OMITTED */
    /* This code must perform the sort by */
    /* ONLY using methods in the interface, why? */
  }

  public static void main(String[] args){
    Vector myVector = new Vector();
    /* Add some things to the list */

    /* This call works because of polymorphism */
    /* myVector is a Vector which IS a list*/
    sort(myVector);
  }

}

More Polymorphism Examples

List myList = new Vector(); //why does this work?

Object something = new String(); //a string IS an object

List myList2 = new List(); //does NOT work, why?

Vector myList3 = new List(); //does NOT work, why?

Polymorphism

• General rule about this in Java is:
  • if the variable being assigned (or parameterized) is a MORE general version of the original, then it is allowed.
  • Likewise, you CANNOT refer to a general object as a more specific type.
    • e.g., If I say give me an animal, you can give me a cat (no problem). but if I say give me a cat, you cannot give me any Animal.