ABSTRACT CLASSES

AND INTERFACES
Abstract methods
You can declare an object without defining it:
Person p;
Similarly, you can declare a method without defining it:
public abstract void draw(int size);
Notice that the body of the method is missing
Instead of { and } you just have a semi colon

A method that has been declared but not defined is an

abstract method
Abstract class
Any class containing an abstract method is an abstract
class
You must declare the class with the keyword abstract:
abstract class MyClass {...}
An abstract class is incomplete
It has missing method bodies
You cannot instantiate (create a new instance of) an
abstract class
Why have abstract classes?
You can extend (subclass) an abstract class
If the subclass defines all the inherited abstract methods, it is
complete and can be instantiated
If the subclass does not define all the inherited abstract
methods, it too must be abstract
You can declare a class to be abstract even if it does not
contain any abstract methods
This prevents the class from being instantiated
Example
Suppose you wanted to create a class Shape, with
subclasses Oval, Rectangle, Triangle, Hexagon, etc.
You dont want to allow creation of a Shape
Only particular shapes make sense, not generic ones
If Shape is abstract, you cant create a new Shape
You can create a new Oval, a new Rectangle, etc.
Abstract classes are good for defining a general category
containing specific, concrete classes
Eating breathing Animals.
public abstract class Animal {
abstract int eat();
abstract void breathe();
}
This class cannot be instantiated
Any non-abstract subclass of Animal must provide the
eat() and breathe() methods
Basic assumption made here is every type of animal has
to eat and breathe!
Common syntax error with subclasses
class Shape { ... }
class Star extends Shape {
void draw() { ... }
...
}
class Crescent extends Shape {
void draw() { ... }
...
}
Shape someShape = new Star();
This is legal, because a Star is a Shape
someShape.draw();
This is a syntax error, because some Shape might not have a draw()
method
Remember: A class knows its superclass, but not its subclasses
Drawing Shapes - power of abstraction
Suppose you are making a GUI, and you want to draw a number of
different shapes (humans, trees, dogs, robots, chuck norris, )

Each class has a draw method

You make these subclasses of a class Shape, so that you can create an
ArrayList<Shape> shapes to hold the various things to be drawn
You would like to do
for (Shape s : shapes)
s.draw();
This isnt legal!

Every class knows its superclass, but a class doesnt know its
subclasses
You may know that every subclass of Shape has a draw method, but Java doesnt
Possible solutions to the shape problem

Solution 1: Put a draw method in the Shape class

This method will be inherited by all subclasses, and will make Java happy
But what will it draw?
Ugly

Solution 2: Put an abstract draw method in the Shape class

This will also be inherited (and make Java happy), but you dont have to define it
You do, however, have to make the Shape class abstract
This way, Java knows that only concrete objects have a draw method
abstract class Shape {
abstract void draw();
}

class Star extends Shape {

void draw() { ... }
...
}
class Crescent extends Shape {
void draw() { ... }
...
}
Shape someShape = new Star();
This is legal, because a Star is a Shape
However, Shape someShape = new Shape(); is no longer legal
someShape.draw();
This is legal, because every actual instance must have a draw() method
Interfaces
An interface declares (describes) methods but does not
supply bodies for them
interface KeyListener {
public void keyPressed(KeyEvent e);
public void keyReleased(KeyEvent e);
public void keyTyped(KeyEvent e);
}
All the methods are implicitly public and abstract
You can add these qualifiers if you like, but why bother?
You cannot instantiate an interface
An interface is like a very abstract classnone of its methods
are defined
An interface may also contain constants (final variables)
When to write an interface
You will frequently use the supplied Java interfaces
Sometimes you will want to design your own
You would write an interface if you want classes of various
types to all have a certain set of capabilities
For example, if you want to be able to create grocery
items, you might define an interface as:
public interface Item{
salePrice();
}
implements != extends
You extend a class, but you implement an interface
A class can only extend (subclass) one other class, but it
can implement as many interfaces as you like
Example:
class MyListener
implements KeyListener, ActionListener { }
implements = signing a binding contract!
When you say a class implements an interface, you are
promising to define all the methods that were declared in
the interface
Example:
class MyKeyListener implements KeyListener {
public void keyPressed(KeyEvent e) {...};
public void keyReleased(KeyEvent e) {...};
public void keyTyped(KeyEvent e) {...};
}
The ... indicates actual code that you must supply
Now you can create a new MyKeyListener
 It is possible for a class to define some but not all of the
methods defined in an interface:
abstract class MyKeyListener implements KeyListener {
public void keyTyped(KeyEvent e) {...};
}
Since this class does not supply all the methods it has
promised, it must be an abstract class
You must label it as such with the keyword abstract
You can even extend an interface (to add methods):
interface FunkyKeyListener extends KeyListener { ... }
Why interfaces?
Reason 1: A class can only extend one other class, but it
can implement multiple interfaces
This lets the class fill multiple roles
In writing user interfaces it is common to have a class be able to
handle different user interactions.
Example:
class MyApplet extends Applet
implements ActionListener, KeyListener {
...
}
Reason 2: You can write methods that work for more than
one kind of class
 You can write methods that work with more than one class
interface RuleSet {
boolean isLegal(Move m, Board b);
void makeMove(Move m);
}

Every class that implements RuleSet must have these methods

class CheckersRules implements RuleSet { // one implementation
public boolean isLegal(Move m, Board b) { ... }
public void makeMove(Move m) { ... }
}
class ChessRules implements RuleSet { ... } // another implementation
class LinesOfActionRules implements RuleSet { ... } // and another
RuleSet rulesOfThisGame = new ChessRules();
This assignment is legal because a rulesOfThisGame object is a RuleSet
object
if (rulesOfThisGame.isLegal(m, b)) { makeMove(m); }
This statement is legal because, whatever kind of RuleSet object
rulesOfThisGame is, it must have isLegal and makeMove methods
instanceof
instanceof is a keyword that tells you whether a variable
is a member of a class or interface
For example, if
class Dog extends Animal implements Pet {...}
Animal fido = new Dog();

then the following are all true:

fido instanceof Dog
fido instanceof Animal
fido instanceof Pet
instanceof is seldom used
When you find yourself wanting to use instanceof, think about
whether the method you are writing should be moved to the
individual subclasses
Abstract classes for interfaces
When you implement an interface, you promise to define
all the functions it declares
There can be a lot of methods
interface KeyListener {
public void keyPressed(KeyEvent e);
public void keyReleased(KeyEvent e);
public void keyTyped(KeyEvent e);
}

What if you only care about a couple of these methods?