interfaces, classes, collections school of engineering and computer science, victoria university of...
TRANSCRIPT
Interfaces, Classes, Collections
School of Engineering and Computer Science, Victoria University of Wellington
CO
MP 1
03
2015-T2 Lecture 3
Thomas Kuehne Thomas Kuehne, Marcus Frean,
RECAP - TODAY2
RECAP Libraries, Collections: the Java Collections Library Interfaces, Abstract Data Types
TODAY More on interface versus class, and the
Collections library Parameterized Types
ADMINISTRIVIA Assignment#1 out today Videos available from “Blackboard”, may need IE
Tutorials will start next week.
3QUICK NOTE: Coding style
I will drop the “this.” except when needed Instead of this.loadFromFile(...)
just loadFromFile(...)
Instead of this.shapes.addShape(shape)
just shapes.addShape(shape)
I will leave out { } when surrounding just one statement
Instead of while (i<name.length) {
name[i] = null;
}
just while (i<name.length)
name[i] = null;
Interface Classes
enables us to say “all shapes must be able to draw themselves” enables us to declare a List of Shapes, without saying exactly
what each shape is going to be.
4Java Interfaces
RectShape
Triange
implements
implements
Oval
implements
public interface Shape {
public void redraw();
:
}
public class Rect implements Shape {
public void redraw() {
UI.drawRect(x,y,…,…).
}
Interfaces Classes
Interfaces can extend other interfaces (the “sub” interface has all the methods of the “super” interface, plus its own methods)
5Java Interfaces (for collections)
ArrayList <E>
Collection <E>
List <E>LinkedList <E>
ext
end
s
implements
implements
extendsim
plem
ents
interface what it is an implementation (= a class) how it is implemented
Interfaces are organised in a hierarchy; they “extend” one another
Parameterised Types7
The structure and access discipline of a collection is the same, regardless of the type of elements in it: A set of Strings, a set of Persons, a set of Shapes, a
set of integers all behave the same way.
⇒ we only want one Interface for each kind of collection. (there is only one Set interface)
Need to specify kind of elements in a particular collection
⇒ The collection Interfaces (and classes) are parameterised:
A generic interface has a “generic” type parameter When declaring a variable of a collection type, you
specify the type of the collection and the actual type of the elements of the collection
In the Interface, we use a placeholder: public interface Set <E> extends Collection <E> {
public void add(E item); /*…description…*/public void remove(E item); /*…description…*/ public boolean contains(E item); /*…description…*/
… // (lots more methods in the Java Set interface)
When declaring a variable, specify the element typeprivate Set <Thing> mystuff;
private List <Shape> drawing;
Parameterised Types8
Collection Type Element Type
Your program can....
1. declare a variable, parameter, or field of the interface type
private List<Thing> myThings; // a list of Thing objects
2. instantiate a collection: myThings = new ArrayList<Thing> ();
3. call methods on that variable, parameter, or field
myThings.add(new Thing(“discombobulator”, “yellow”, “huge”));
myThings.get(3).toString();
Using Java Collection Interfaces
9
Aside: this won’t work. Why not?
Why can’t this be “List”?
Polymorphism applies, as usual. So you can do this…
1. declare a variable, parameter, or field of the interface type, as in
private List <Shape> drawing; // a list of Shape objects
2. instantiate an object, as in
drawing= new ArrayList <Shape> ();
3. call methods on that variable, parameter, or field, as in
drawing.add(new Rect(100, 100, 20, 30));
...so long as the Rect class implements the Shape interface:
public class Rect implements Shape {.....
Another Example10
Collection <E> isEmpty() → booleansize() → intcontains(E elem) → booleanadd(E elem) → boolean (whether it succeeded)remove(E elem) → boolean (whether it removed an item)iterator() → iterator <E>
…List <E>add(int index, E elem)remove(int index) → E (returns the item removed)get(int index) → Eset(int index, E elem) → E (returns the item replaced)indexOf(E elem) → intsubList(int from, int to) → List<E>…
11Methods on Collection and List
Methods on all types of collections
Additional methods on all Lists
Wanted: a collection of tasks, in order they should be done.
Requirements of TasksOrganiser:
read list of tasks from a file
display all the tasks
add task, at end, or at specified position
remove task
move task to a different position. List
Task
Wanted: a collection of tasks, in order they should be done.
Requirements of TasksOrganiser:
Collection type:
Element type:
12Example
13Example (TasksOrganiser program)public class TasksOrganiser {
private List<Task> tasks; /* read a list of tasks from a file, */
public void readTasks(String fname) {
try {
Scanner taskScanner= new Scanner(new File(fname)); tasks = new ArrayList<Task>(); while ( taskScanner.hasNext() ) tasks.add(new Task(taskScanner.next()));
taskScanner.close();
} catch(IOException e) {…}
displayTasks();
}
...
...
public void displayTasks(){UI.print(tasks.size() + “ tasks to be done:\n”);
// You could do it this way (uses the standard “for” loop)for (int i=0; i<tasks.size(); i++) UI.print(tasks.get(i) + "\n");
// or this way instead (uses the “for each” syntax)for (Task task : tasks) UI.print(task + "\n");
// There is even a third way (use an iterator)Iterator <Task> iter = tasks.iterator();
while (iter.hasNext()){UI.print(iter.next() + "\n");
}
14Iterating through List
Actually, the “for each” syntax is just a shortcut for
using an iterator. More on this later.
No size limit! Lists grow bigger as necessary More functionality, such as
“addAll(anotherCollection)”
List vs ArraytaskList.set(ind, value) taskArray[ind] = value
taskList.get(ind) taskArray[ind]
taskList.size() ? Not same as length of the array!
taskList.add(value) ? Where is the last value? What happens if it’s full?
taskList.add(ind, value) ? Have to shift everything up!!
taskList.remove(ind) ? Have to shift everything down!!
taskList.remove(value) ? Have to find value, then shift things down!!
for (Task t : tasks) for( int i = 0; i< ???; i++) Task t = taskArray[ i ];
15Lists are nicer than arrays