cs/engrd 2110 spring2018 - cornell university · abstract class used to “define” a type...
TRANSCRIPT
CS/ENGRD 2110SPRING 2018Lecture 7: Interfaces and Abstract Classeshttp://courses.cs.cornell.edu/cs2110
1
St Valentine’s Day!2
It's Valentines Day, and so fine!Good wishes to you I consign.*But since you're my students,I have to show prudence.I won't call you my Valentine.
Today is Valentine's Day. According to Wikipedia, it originated as a day honoring two saints named Valentinus, but around the years 1000..1250 it became associated with a tradition of courtly love. The day first became associated with romantic love within Geoffrey Chaucer’ circle in the 14th century. Later, in 18th century England, it evolved into what it is today: an occasion in which lovers express their love for each other by presenting flowers, confectionery, greeting cards, or whatever.
To ask you all to "be my Valentine" wouldn't be prudent. It might cause us problems, given our teacher-student relationship. But I can and do wish you a happy day. And I and the CS2110 will continue to serve you, attempting to give you the best course possible. gries
*consign: commit forever, commit irrevocably.
Announcements3
A2 is due tonight (15 February)
Get started on A3 – a method every other day. You have twiweeks.
A3 asks you to learn about an interesting data structure, the linked list, by reading on your own.
Don’t be concerned with applications of the linked list. You’ll see many uses of linked lists in the rest of the course!
3
About A3. linked list data structure4
This is a linked list containing the list of integers (6, 7, 3).
4
header, containing size of list and pointer to first node
Each node (N@1, N@8, N@2)contains a value of the list and apointer to next node (null if none)
Why use linked list? Can insert a value at beginning of list with just a few instructions ---constant time
A3 introduces generics5
5
Generic programming: a style of computer programming in which algorithms are written in terms of types to be specified later, which are then instantiated when needed for specific types .
A3 introduces generics6
/** An instance maintains a set of some max size. */public class TimeSet {
private Entry[] s; // The set elements are in s[0..n-1]private int n; // size of set.
}6
new TimeSet(10)
This set can contain anyvalues, e.g. {6, “xy”, 5.2, ‘a’}
<E> // E is a type parameter
new TimeSet<String>(10)
This set can contain only Strings, e.g. {“xy”, “a”}
A3 introduces generics7
/** An instance maintains a set of some max size. */public class TimeSet {
private Entry[] s; // The set elements are in s[0..n-1]private int n; // size of set.
}7
<E> // E is a type parameter
A3 introduces inner classes8
/** An instance represents a linked list … */public class TimeSet {
private Node first; // first node of list (null if size 0)private int size; // Number of values.
}8
<E> // E is a type parameter
Note how type parameter E is used
new TimeSet<String> // E will be String
/** An instance holds an E element. */private class Entry {
private E val; // the element of type Eprivate long t; // the time at which entry was created.
A Little Geometry!9
(x, y)
9
Position of a rectangle in the plane is given by its upper-left corner
Position of a circle in the plane is given by the upper-left corner of its bounding box
(x, y)
A Little Geometry!Abstract Classes
Shapex ____y ____
Trianglearea() base____height ____
Circlearea()radius __5__
Rectanglearea()width ____height ____
class Shape contains the coordinates of a shape in the plane. Each subclassdeclares the fields to contain the size and function area
Write variables as lines instead of boxes
1010
Problem: Don’t like creation of Shape objectsAbstract Classes
Shapex ____y ____
Circlearea()radius __5__
Rectanglearea()width ____height ____
PROBLEMSince an object of Shape is not really a shape, don’t want to allow creation of objects of class Shape!
Syntactic rule: if a class C is abstract, the new-expression new C(…) cannot be used!
Solutionpublic abstract class Shape {
…}
1111
Attempt at writing function sumAreas
/** Return sum of areas of shapes in s */public static double sumAreas(Shape[] s) {
}
Problem:Don’t want to check type of s[k] and cast down.
Abstract Classes
double sum= 0;for (int k= 0; k < s.length; k= k+1)
sum= sum + s[k].area();return sum; compile-time reference rule:
s[k].area illegal, won’t compile.
1212
A Partial Solution:
Add method area to class Shape:
Abstract Classes
public double area() {return 0;
}
Problem: a subclass might forget to override area().
1313
Good solution:
In abstract class Shape, to require all subclassesto override function area, make it abstract:
Abstract Classes
public abstract class Shape {…/** Return the area of this shape */public abstract double area() ;
}
Syntax:If a method has keyword abstract in its declaration, use a semicolon instead of a method body
1414
Abstract Summary
1. To make it impossible to create an instance of a class C, make C abstract:
public abstract C { …}
2. In an abstract class, to require each subclass to override method m(…), make m abstract:
public abstract int m(…) ;
Abstract Classes
Syntax: the program cannot be compiled if C is abstract and there is anew-expression new C(…)
Syntax: the program cannot be compiled if a subclass of an abstract class does not override an abstract method.
1515
Abstract class used to “define” a type(abstract data type — ADT)
Stack: implementation of a list that allows (only) pushes and pops
16 16
From wikipedia
Abstract class used to “define” a type(abstract data type — ADT)
Type: set of values together with operations on them
Suppose we want to define type Stack (of ints). It’s operations are:
isEmpty() --return true iff the stack is emptypush(k) --push integer k onto the Stackpop() --pop the top stack element
public abstract class Stack {public abstract boolean isEmpty();public abstract void push(int k);public abstract int pop();
}
Naturally, need specifications
17 17
This defines an ADT. We have the syntax of operations. Javadoc comments will describe values and operations
Example of subclasses of
Stack
public abstract class Stack {public abstract boolean isEmpty();public abstract void push(int k);public abstract int pop();
}
public class ArrayStack extends Stack{private int n; // stack elements are inprivate int[] b; // b[0..n-1]. b[0] is bottom
/** Constructor: An empty stack of max size s. */public ArrayStack(int s) {b= new int[s];}
public boolean isEmpty() {return n == 0;}
public void push(int v) { b[n]= v; n= n+1;}
public int pop() {n= n-1; return b[n]; }}
Missing lots of
tests for errors!
Missing specs!
18 18
Example of subclasses of
Stack
public abstract class Stack {public abstract boolean isEmpty();public abstract void push(int k);public abstract int pop();
}
public class LinkedListStack extends Stack{private int n; // number of elements in stackprivate Node first; // top node on stack
/** Constructor: An empty stack */public LinkedListStack() {}
public boolean isEmpty() {return n == 0;}
public void push(int v) { prepend v to list}
public int pop() { …}}
Missing lots of
tests for errors!
Missing specs!
19 19
Flexibility! public abstract class Stack { … }
public class LinkedListStack extends Stack { … }
public class ArrayStack extends Stack { … }
/** A class that needs a stack */public class C {
Stack st= new ArrayStack(20); …public void m() {
}}
Choose an array implementation,
max of 20 values
Store the ptr in a
variable of type Stack!
…st.push(5);… Use only methods
available in abstract class Stack
20 20
Flexibility! public abstract class Stack { … }
public class LinkedListStack extends Stack { … }
public class ArrayStack extends Stack { … }
/** A class that needs a stack */public class C {
Stack st= new ArrayStack(20); …public void m() {
}}
…st.push(5);…
Want to use a linked list instead of an
array? Just change the new-expression!
LinkedListStack();
21 21
InterfacesAn interface is like an abstract class all of whose components are public abstract methods. Just have a different syntax
22
We don’t tell you immediately WHY Java has this feature, this construct. First let us define the interface and see how it is used. The why will become clear as more and more examples are shown.
(an interface can have a few other kinds of components, but they are limited. For now, it is easiest to introduce the interface by assuming it can have only public abstract methods and nothing else. Go with that for now!)
InterfacesAn interface is like an abstract class all of whose components are public abstract methods. Just have a different syntax
public abstract class Stack {public abstract boolean isEmpty();public abstract void push(int k);public abstract int pop();
}
23
Here is an abstract class. Contains
only public abstract methods
public interface Stack {public abstract boolean isEmpty();public abstract void push(int k);public abstract int pop();
}
Here is how we declare it as an
interface
Interfacespublic abstract class Stack {public abstract boolean isEmpty();public abstract void push(int k);public abstract int pop();
}
public interface Stack {boolean isEmpty();void push(int k);int pop();
}
24
Since methods have to be public and abstract, we can leave off those keywords.
Extend a classclass StackArray
extends Stack {…
}
Implement an interfaceclass StackArray
implements Stack {…
}
25
Mammal
Human ParrotDog
Bird
Animal
A start at understanding use of interfacesHave this class hierarchy:
class Animal { … }class Mammal extends Animal { ... }class Bird extends Animal { … }class Human extends Mammal {. … }class Dog extends Mammal { … }class Parrot extends Bird { … }
26
Mammal
Human ParrotDog
Bird
Animal
A start at understanding use of interfacesHumans and Parrots can whistle. Other Animals cannot.“listenTo” is given as a whistling method:
public void listenTo(String w) { System.out.println(w); }
We need a way of indicating thatclasses Human and Parrothave this method listenTo
public interface Whistle {void listenTo(String w) ;
}
public class Human extends Mammalimplements Whistle {
…public void listenTo(String w) {
System.out.println(w);}
}
(similarly for Parrot)
27
Mammal
Human ParrotDog
Bird
Animal
A start at understanding use of interfaces
Whistle
28
Here’s what an object of class Human looks likepublic interface Whistle { void listenTo(String w) ; }
public class Human extends Mammal implements Whistle {…public void listenTo(String w) { …}
}
Human@1
Animal
Mammal
Human
Usual drawing of object
Mammal
Human
Animal
Draw it this way Add interface dimension
Whistle
29
Here’s what an object of class Human looks likepublic interface Whistle { void listenTo(String w) ; }
public class Human extends Mammal implements Whistle {…public void listenTo(String w) { …}
}
Mammal
Human
Animal
Whistle
A dimension for each class that is extended and interface
that is implemented
30
Here’s what an object of class Human looks like
Human h= new Human();Object ob= h;Animal a= (Animal) ob;Mammal m= h;Whistle w= h;
Mammal
Human
Animal
Whistle
h, ob, a, m, and w all point to the same object.
The object can be (and is) cast to any “partition” in it: h, ob, a, m, and w.
Upward casts: can be implicit; inserted by JavaDownward casts: must be explicit
31
A real use of interface: sorting
Consider an array of Shapes: want to sort by increasing area
Consider an array of ints: want to sort them in increasing order
Consider an array of Dates: want to put in chronological order
We don’t want to write three different sorting procedures!
The sorting procedure should be the same in all cases. What differs is how elements of the array are compared.
So, write ONE sort procedure, tell it the function to be used to compare elements. To do that, we will use an interface.
32
Interface Comparable<T>
Package java.lang contains this interface
public interface Comparable<T> {/** = a negative integer if this object < c,
= 0 if this object = c,= a positive integer if this object > c.Throw a ClassCastException if c can’t
be cast to the class of this object. */int compareTo(T c);
}
33
Real example: Comparable<T>
We implement Comparable<T> in class Shape
public abstract class Shape {…/** Return the area of this shape */public abstract double area() ;
}
/** Return negative number, 0, or a positive numberdepending on whether this are is <, =, or > c’s area */
public int compareTo(Shape c) {double diff= area() – c.area();return diff == 0 ? 0 : (diff < 0 ? -1 : 1);
Implements Comparable<Shape>
34
Arrays.sort has this method.
/** Sort array b. Elements of b must implement interface Comparable<T>. Its method compareTo is used to determine ordering of elements of b. */Arrays.sort(Object[] b)
Shape implements Comparable, so we can write// Store an array of values in shapesShape[] shapes= ...; ...
Arrays.sort(shapes);
35
What an object of subclasses look likepublic abstract class Shape implements Comparable<Shape>{ … }public class Circle extends Shape { … }public class Rectangle extends Shape { … }
Shape
Circle
Object Comparable
Shape
Rectangle
Object Comparable
When sort procedure is comparing elements of a Shape array, each element is a Shape. Sort procedure views it from Comparable perspective!
Abstract Classes vs. Interfaces
● Abstract class represents something
● Share common code between subclasses
● Interface is what something can do. Defines an “abstract data type”
● A contract to fulfill● Software engineering
purposeSimilarities:● Can’t instantiate● Must implement abstract methods● Later we’ll use interfaces to define “abstract data types” ○ (e.g. List, Set, Stack, Queue, etc)
3636