CISC 181

Abstract classes & interfaces

Prof. Christopher Rasmussen

​

April 6, 2015

News

• Lab #7 today
• Midterms will be returned on Wednesday

Derived Classes

• Object-oriented languages such as Java allow classes to be derived from each other
• So we say the more specific Fish class is based on the more general Animal class, but it "extends" or "modifies" it in some way

​

public class Animal { … }

public class Fish extends Animal { … }

instanceof

• Test whether an object o comes from a certain class A, or from a class derived from class B, with boolean instanceof operator

if (o instanceof A) { … }

​

​

​

null

• null can be assigned to reference variables to indicate that they are not associated with any object
• Alternative to new when you are getting a "variable might not have been initialized" error

​

null

• null can be assigned to reference variables to indicate that they are not associated with any object
• Alternative to new when you are getting a "variable might not have been initialized" error
• null has no type -- any variable that is null will return false for all instanceof tests

Abstract class

• Guides design of subclasses through members, but no object can be instantiated from it
• Opposite of "concrete" class, which is what we know about so far

​

Example: JComponent

• A Swing JFrame can contain all kinds of GUI elements
• The types of components are organized hierarchically

​

​

​

​

​

​

abstract

Abstract class

• Guides design of subclasses through members, but no object can be instantiated from it
• Opposite of "concrete" class, which is what we know about so far
• Use keyword abstract before class

​

Abstract class

• Guides design of subclasses through members, but no object can be instantiated from it
• Opposite of "concrete" class, which is what we know about so far
• Use keyword abstract before class
• abstract method
• Empty body -- for example:

abstract void methodName( … );

​

Abstract class

• Guides design of subclasses through members, but no object can be instantiated from it
• Opposite of "concrete" class, which is what we know about so far
• Use keyword abstract before class
• abstract method
• Empty body -- for example:

abstract void methodName( … );

• Must be in abstract class

​

Abstract class

• Guides design of subclasses through members, but no object can be instantiated from it
• Opposite of "concrete" class, which is what we know about so far
• Use keyword abstract before class
• abstract method
• Empty body -- for example:

abstract void methodName( … );

• Must be in abstract class
• Must be overridden and defined in subclass

Example: Shape

abstract class Shape {

…

abstract double computeArea();

}

​

Example: Shape

abstract class Shape {

…

abstract double computeArea();

}

​

class Circle extends Shape {

double computeArea()

{ return Math.PI * radius * radius; }

}

​

​

Example: Shape

abstract class Shape {

…

abstract double computeArea();

}

​

class Circle extends Shape {

double computeArea()

{ return Math.PI * radius * radius; }

}

​

class Rectangle extends Shape {

double computeArea()

{ return width * height; }

}

Abstract classes & polymorphism

• Recall that you can put Fish (subclass) objects into an ArrayList of Animal (superclass) objects and Java "knows" which is which
• You can always assign a subclass object to a superclass-type variable, but not vice versa...why?

​

Abstract classes & polymorphism

• Recall that you can put Fish (subclass) objects into an ArrayList of Animal (superclass) objects and Java "knows" which is which
• You can always assign a subclass object to a superclass-type variable, but not vice versa...why?
• Convenient to have ArrayList where element type is abstract base class

interfaces

• An interface is like an abstract class, with some key differences

​

interfaces

• An interface is like an abstract class, with some key differences
• Syntax
• Use interface instead of class in definition
• Use implements instead of extends to associate a class with an interface

​

interfaces

• An interface is like an abstract class, with some key differences
• Syntax
• Use interface instead of class in definition
• Use implements instead of extends to associate a class with an interface
• Properties
• All methods are implicitly public and abstract
• So make your overrides public
• Class can implement multiple interfaces -- put in comma-separated list:

class A implements I1, I2 { … }

More about interfaces

• Can also use instanceof to test whether object implements a certain interface

​

More about interfaces

• Can also use instanceof to test whether object implements a certain interface
• interfaces can't implement other interfaces

​

More about interfaces

• Can also use instanceof to test whether object implements a certain interface
• interfaces can't implement other interfaces
• All fields implicitly static & final

​

More about interfaces

• Can also use instanceof to test whether object implements a certain interface
• interfaces can't implement other interfaces
• All fields implicitly static & final
• Can declare default methods with bodies which are shared by implementing classes
• This allows you to add a method to an existing interface without "breaking" implementations
• Can still be overridden

Example interface: Comparable<T>

• Defines "total ordering" on class objects
• Has one method: int compareTo(T)
• Remember: returns 0 if equal, negative if less than, positive if greater than

​

Example interface: Comparable<T>

• Defines "total ordering" on class objects
• Has one method: int compareTo(T)
• Remember: returns 0 if equal, negative if less than, positive if greater than
• Necessary to implement for your objects to be sortable by Java Collections sort()

​

Limitations of Comparable<T>

• Must have access to class T to make it implement the interface

Limitations of Comparable<T>

• Must have access to class T to make it implement the interface
• There is only one kind of ordering on T -- whatever is built into compareTo()

​

Example interface: Comparator<T>

• Define class outside T which overrides one method:

int compare(T o1, T o2)

​

Example interface: Comparator<T>

• Define class outside T which overrides one method:

int compare(T o1, T o2)

• Like compareTo(), but two arguments: returns negative number if o1 < o2, 0 if they're equal, and positive number otherwise

​

Example interface: Comparator<T>

• Define class outside T which overrides one method:

int compare(T o1, T o2)

• Like compareTo(), but two arguments: returns negative number if o1 < o2, 0 if they're equal, and positive number otherwise
• Allows you to customize what T is sorted on: alphabetically, numerically, field 1 vs. field 2, etc.

​

Example interface: Comparator<T>

• Define class outside T which overrides one method:

int compare(T o1, T o2)

• Like compareTo(), but two arguments: returns negative number if o1 < o2, 0 if they're equal, and positive number otherwise
• Allows you to customize what T is sorted on: alphabetically, numerically, field 1 vs. field 2, etc.
• Pass comparator object as second argument to sort()

Comparator<T> example with sort()

class ByAlpha extends Comparator<String> {

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

}

​

class ByLength extends Comparator<String> {

public int compare(String o1, String o2) {

return (o1.length() - o2.length());

}

}

​

​

​