CS 106 Introduction to Computer Science I 04 / 30 / 2007 Last lecture :( Instructor: Michael Eckmann

Michael Eckmann - Skidmore College - CS Spring 2007 Today’s Topics questions, comments? Designing for polymorphism discussion ArrayLists

Designing for polymorphism Polymorphism allows a consistent approach to inconsistent but related behaviors. What does that mean? First examine the problem to find opportunities that lend themselves to this before we write code. Let's look at some example situations and discuss them.

Designing for polymorphism Different types of vehicles move in different ways All business transactions for a company must be logged All products produced by a company must meet certain quality standards A hotel needs to plan their remodeling efforts for every room A casino wants to analyze the profit margin for their games A dispatcher must schedule moving vans and personnel based on the job size A drawing program allows the user to draw various shapes

ArrayList This is a good time to bring up a class in Java API named ArrayList, because it works on general Objects. ArrayList is a class in the Java API It can store different types of data into an “array” An ArrayList can change size throughout the lifetime of the program – whereas a regular array is a fixed size An ArrayList actually stores references to objects, not the objects themselves We cannot store values of primitive types directly -- we have to use the wrapper classes if we want to do that (we'll see what this means later).

ArrayList Some ArrayList methods – ArrayList() --- constructor – boolean add(Object o) – add the object reference to the end of the list – void add(int index, Object o) – add the object reference to the list at the index – void clear() -- remove all elements from the list – Object get(int index) – return the object reference at that index in the list – int indexOf(Object o) – returns the index of the first occurrence of o – boolean isEmpty() -- returns true if the list contains no elements, false otherwise

ArrayList Some ArrayList methods – Object remove(int index) – returns the object reference at that index in the list and removes it from the list – int size() – returns the number of elements in the list – boolean contains(Object o) -- returns true if the list contains o, false otherwise – void ensureCapacity(int minCapacity) – tells Java to ensure that the list will be able to contain at least minCapacity references – int lastIndexOf(Object o) – what do you think this does? – boolean remove(Object o) -- removes a single instance of o from the list – void removeRange(int fromIndex, int toIndex) --removes from the list all of the elements whose index is between fromIndex, inclusive and toIndex, exclusive.

ArrayList Some ArrayList methods – Object set(int index, Object o) -- replaces the element at the specified index in this list with o. – What if this method wasn't in the class. How might you achieve that functionality?

ArrayList Let's create an ArrayList of different types and add some elements to it and remove some, etc... When we create one that allows different types, we have to cast any returned Objects from methods to be the type we want. Because Java implemented ArrayLists generically, and because of the way Java decided to have the class hierarchy such that all classes have Object as their superclass, this usefulness of ArrayLists is dramatically increased over a class that may have only allowed one type for its elements. So, that's a large benefit of good object oriented design --- generality --- so that you (or the Java implementers themselves) don't have to implement multiple classes to work on multiple types. If you create your class hierachy well, lots of stuff can be done generically (e.g. Have code that works on all Pets instead of just Dog or Cat objects for instance.)

ArrayList If we stored several different types of data in a list, we may not know at some point what type of object is actually stored in a particular index of the ArrayList. How do we find out what type a particular object actually is?

ArrayList If we stored several different types of data in a list, we may not know at some point what type of object is actually stored in a particular index of the ArrayList. How do we find out what type a particular object actually is? We can use the instanceof operator to check if some reference is an instance of some type. e.g. Object o = somearraylist.get(0); if (o instanceof Contact) { //then cast o to be a Contact and use it }

ArrayList Let's look at how each method affected the list and what they returned. – ArrayList(), boolean add(Object o), – void add(int index, Object o), void clear(), Object get(int index), – int indexOf(Object o), boolean isEmpty(), – Object remove(int index), int size(), boolean contains(Object o), – void ensureCapacity(int minCapacity), – int lastIndexOf(Object o), boolean remove(Object o), – protected void removeRange(int fromIndex, int toIndex)

Polymorphism via Inheriance An ArrayList uses polymorphism because it holds references to objects of Object. An Object reference can be used to refer to any object (of any type)!!!

Linked lists A linked list is a data structure where every node contains data and reference(s) to other node(s.)

Linked lists In a singly linked list every node contains data and one reference to another node. –e.g. class Node { public AnyType data; // can have more data than one public Node next; } A Linked List is maintained by keeping a reference to the head of the list. From the head, we are able to get at all the other nodes in the list by following the next reference.

Linked lists class Node { public AnyType data; // can have more data than one public Node next; // when constructing a new node, we set its data and // set the next reference to null public Node(AnyType d) { data = d; next = null; }

Linked lists Node n = new Node(somedata); Node head; head = n; // sets n to be the head of the linked list Node newnode = new Node(somedata2); // to add a newnode to the beginning of the list: newnode.next = head; head = newnode;

Linked lists Node newnode = new Node(somedata2); // to add a newnode to the end of the list: Node currnode; currnode = head; while (currnode != null) { savenode = currnode; currnode = currnode.next; } savenode.next = newnode;

Linked lists Let's figure out how to – Insert after a particular node // insert newnode after findnode // head currnode = head; while (!((currnode.card).equals(findnode.card))) { currnode = currnode.next; } newnode.next = currnode.next; currnode.next = newnode;

Linked lists Let's figure out how to – Delete a node // delete findnode // head Node prevnode; Node currnode = head; while (!((currnode.card).equals(findnode.card))) { prevnode = currnode; currnode = currnode.next; } prevnode.next = currnode.next; currnode = null;

Linked lists Let's figure out how to – Insert after a particular node – Delete a particular node Other options – Storing link to last node – Doubly linked lists (and their operations.)

Linked lists A doubly linked list is a data structure where every node contains – data – a reference to previous node – a reference to next node What do you think the value of the next node is for the last element of a linked list? What do you think the value of the previous node is for the first element of a linked list?

Linked lists Let's implement our deck of cards as a linked list of card nodes instead of as an array of cards.