Java interfaces & abstract classes

Abstract Classes and Interfaces
The objectives of this chapter are:
To explore the concept of abstract classes
To understand interfaces
To understand the importance of both.

What is an Abstract class?
Superclasses are created through the process called
"generalization"
Common features (methods or variables) are factored out of object
classifications (ie. classes).
Those features are formalized in a class. This becomes the superclass
The classes from which the common features were taken become
subclasses to the newly created super class

Often, the superclass does not have a "meaning" or does not
directly relate to a "thing" in the real world
It is an artifact of the generalization process
Because of this, abstract classes cannot be instantiated
They act as place holders for abstraction

Abstract Class Example
In the following example, the subclasses represent objects
taken from the problem domain.
The superclass represents an abstract concept that does not
exist "as is" in the real world.

Abstract superclass:

Vehicle
- make: String
- model: String
- tireCount: int

Car
- trunkCapacity: int

Note: UML represents abstract
classes by displaying their name
in italics.

Truck
- bedCapacity: int

Be careful not to over use abstract classes
Every abstract class increases the complexity of your
design
Every subclass increases the complexity of your design
Ensure that you receive acceptable return in terms of functionality given
the added complexity.

Defining Abstract Classes
Inheritance is declared using the "extends" keyword
If inheritance is not defined, the class extends a class called Object
public abstract class Vehicle
{
private String make;
private String model;
private int tireCount;
[...]

public class Car extends Vehicle
{
private int trunkCapacity;
[...]

public class Truck extends Vehicle
{
private int bedCapacity;
[...]

Vehicle
- make: String
- model: String
- tireCount: int

Car

Truck
- bedCapacity: int

Often referred to as "concrete" classes

Abstract Methods
Methods can also be abstracted
An abstract method is one to which a signature has been provided, but
no implementation for that method is given.
An Abstract method is a placeholder. It means that we declare that a
method must exist, but there is no meaningful implementation for that
methods within this class

Any class which contains an abstract method MUST also be
abstract
Any class which has an incomplete method definition cannot
be instantiated (ie. it is abstract)
Abstract classes can contain both concrete and abstract
methods.
If a method can be implemented within an abstract class, and
implementation should be provided.

Abstract Method Example
In the following example, a Transaction's value can be
computed, but there is no meaningful implementation that can
be defined within the Transaction class.
How a transaction is computed is dependent on the transaction's type
Note: This is polymorphism.

Transaction
- computeValue(): int

RetailSale

StockTrade

Defining Abstract Methods
Inheritance is declared using the "extends" keyword
If inheritance is not defined, the class extends a class called Object
Note: no implementation
public abstract class Transaction
{
public abstract int computeValue();

Transaction

public class RetailSale extends Transaction
{
RetailSale
public int computeValue()
{
[...]
public class StockTrade extends Transaction
{
public int computeValue()
{
[...]

StockTrade

What is an Interface?
An interface is similar to an abstract class with the following
exceptions:
All methods defined in an interface are abstract. Interfaces can contain
no implementation
Interfaces cannot contain instance variables. However, they can
contain public static final variables (ie. constant class variables)
•

Interfaces are declared using the "interface" keyword
If an interface is public, it must be contained in a file which
has the same name.

•

Interfaces are more abstract than abstract classes

•

Interfaces are implemented by classes using the
"implements" keyword.

Declaring an Interface
In Steerable.java:
public interface Steerable
{
public void turnLeft(int degrees);
public void turnRight(int degrees);
}

In Car.java:

When a class "implements" an
interface, the compiler ensures that
it provides an implementation for
all methods defined within the
interface.

public class Car extends Vehicle implements Steerable
{
public int turnLeft(int degrees)
{
[...]
}
public int turnRight(int degrees)
{
[...]
}

Implementing Interfaces
A Class can only inherit from one superclass. However, a
class may implement several Interfaces
The interfaces that a class implements are separated by commas
•

Any class which implements an interface must provide an
implementation for all methods defined within the interface.
NOTE: if an abstract class implements an interface, it NEED NOT
implement all methods defined in the interface. HOWEVER, each
concrete subclass MUST implement the methods defined in the
interface.

•

Interfaces can inherit method signatures from other
interfaces.

Declaring an Interface
In Car.java:
public class Car extends Vehicle implements Steerable, Driveable
{
public int turnLeft(int degrees)
{
[...]
}
public int turnRight(int degrees)
{
[...]
}
// implement methods defined within the Driveable interface

Inheriting Interfaces
If a superclass implements an interface, it's subclasses also
implement the interface
public abstract class Vehicle implements Steerable
{
private String make;
[...]

public class Car extends Vehicle
{
private int trunkCapacity;
[...]

public class Truck extends Vehicle
{
private int bedCapacity;
[...]

Vehicle
- make: String
- model: String
- tireCount: int

Car

Truck
- bedCapacity: int

Multiple Inheritance?
Some people (and textbooks) have said that allowing classes
to implement multiple interfaces is the same thing as multiple
inheritance
This is NOT true. When you implement an interface:
The implementing class does not inherit instance variables
The implementing class does not inherit methods (none are defined)
The Implementing class does not inherit associations

Implementation of interfaces is not inheritance. An interface
defines a list of methods which must be implemented.

Interfaces as Types
When a class is defined, the compiler views the class as a
new type.
The same thing is true of interfaces. The compiler regards an
interface as a type.
It can be used to declare variables or method parameters
int i;
Car myFleet[];
Steerable anotherFleet[];
[...]
myFleet[i].start();
anotherFleet[i].turnLeft(100);
anotherFleet[i+1].turnRight(45);

Abstract Classes Versus Interfaces
When should one use an Abstract class instead of an
interface?
If the subclass-superclass relationship is genuinely an "is a"
relationship.
If the abstract class can provide an implementation at the appropriate
level of abstraction
•

When should one use an interface in place of an Abstract
Class?
When the methods defined represent a small portion of a class
When the subclass needs to inherit from another class
When you cannot reasonably implement any of the methods

Difference Between Interface and
Abstract Class


Main difference is methods of a Java interface are
implicitly abstract and cannot have
implementations. A Java abstract class can
have instance methods that implements a default
behavior.

Abstract Class


Variables declared in a Java interface is by
default final. An abstract class may contain nonfinal variables.

Abstract Class


Members of a Java interface are public by default.
A Java abstract class can have the usual flavors of
class members like private, protected, etc..

Abstract Class


Java interface should be implemented using
keyword “implements”; A Java abstract class
should be extended using keyword “extends”.

Abstract Class


An interface can extend another Java interface
only, an abstract class can extend another Java
class and implement multiple Java interfaces.

Abstract Class


A Java class can implement multiple interfaces but
it can extend only one abstract class.



Interface is absolutely abstract and cannot
be instantiated; A Java abstract class also cannot be
instantiated, but can be invoked if a main() exists.

Abstract Class


In comparison with java abstract classes, java
interfaces are slow as it requires extra indirection.

A fact about Interfaces


A Java class may implement, and an interface may
extend, any number of interfaces; however an
interface may not implement an interface.

Java interfaces & abstract classes

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

a method that has been declared but not defined is
an abstract method

abstract classes I


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

abstract classes II


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

why have abstract classes?




suppose you wanted to create a class Shape, with
subclasses Oval, Rectangle, Triangle, Hexagon,
etc.
you don’t want to allow creation of a “Shape”



if Shape is abstract, you can’t create a new Shape




only particular shapes make sense, not generic ones
you can create a new Oval, a new Rectangle, etc.

abstract classes are good for defining a general
category containing specific, “concrete” classes

an example abstract class


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

why have abstract methods?



suppose you have a class Shape that isn’t abstract





Shape should not have a draw() method
each subclass of Shape should have a draw() method

now suppose you have a variable Shape figure; where figure contains some
subclass object (such as a Star)




it is a syntax error to say figure.draw(), because the Java compiler can’t tell in
advance what kind of value will be in the figure variable

solution: Give Shape an abstract method draw()


now the class Shape is abstract, so it can’t be instantiated



the figure variable cannot contain a (generic) Shape, because it is impossible to
create one



any object (such as a Star object) that is a (kind of) Shape will have the draw()
method



the Java compiler can depend on figure.draw() being a legal call and does not give a
syntax error

a problem








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

a solution








abstract class Shape {
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 cannot instantiate an interface




you can add these qualifiers if you like, but why bother?

an interface is like a very abstract class—none of its methods are defined

an interface may also contain constants (final variables)

“constants”


a constant is a variable, or field, that is marked
final
public final int SPRING = 0;
public final int SUMMER = 1;
public final int FALL = 2;
public final int WINTER = 3;



its value cannot be changed at runtime



its name should, by convention, be all caps

designing interfaces


most of the time, you will use Sun-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 animated displays of objects in a
class, you might define an interface as:




public interface Animatable {
install(Panel p);
display();
}

now you can write code that will display any Animatable class in a Panel of your
choice, simply by calling these methods

implementing an interface I


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
{…}

implementing an interface II




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

partially implementing an Interface



it is possible 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 is 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
{ ... }

what are interfaces for?


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 Applets, it is common to have one class
implement several different listeners



example:
class MyApplet extends Applet
implements ActionListener, KeyListener {
...
}



reason 2: you can write methods that work for
more than one kind of class

how to use interfaces




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 method 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

interfaces, again


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?

adapter classes


solution: use an adapter class



an adapter class implements an interface and provides empty method bodies
class KeyAdapter implements KeyListener {
public void keyPressed(KeyEvent e) { };
public void keyReleased(KeyEvent e) { };
public void keyTyped(KeyEvent e) { };
}



you can override only the methods you care about



this isn’t elegant, but it does work



Java provides a number of adapter classes

vocabulary


abstract method —a method which is
declared but not defined (it has no method
body)



abstract class —a class which either (1)
contains abstract methods, or (2) has been
declared abstract



instantiate —to create an instance (object) of
a class



interface —similar to a class, but contains
only abstract methods (and possibly
constants)



adapter class —a class that implements an

Java interfaces & abstract classes

More Related Content

What's hot (20)

Similar to Java interfaces & abstract classes (20)

More from Shreyans Pathak (7)

Recently uploaded (20)

Java interfaces & abstract classes