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 superclassThe 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 instantiatedThey act as place holders for abstraction

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

Car- trunkCapacity: int

Abstract superclass:

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.

Truck- bedCapacity: int

Note: UML represents abstractclasses by displaying their namein italics.

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

Defining Abstract Classes

Inheritance is declared using the "extends" keywordIf 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;[...]

Often referred to as "concrete" classes

Abstract Methods

Methods can also be abstractedAn 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 typeNote: This is polymorphism.

Transaction- computeValue(): int

RetailSale- computeValue(): int

StockTrade- computeValue(): int

Defining Abstract Methods

Inheritance is declared using the "extends" keywordIf inheritance is not defined, the class extends a class called Object

public abstract class Transaction{public abstract int computeValue();

public class RetailSale extends Transaction{public int computeValue(){

[...]

Transaction- computeValue(): int

RetailSale- computeValue(): int

StockTrade- computeValue(): int

public class StockTrade extends Transaction{public int computeValue(){

[...]

Note: no implementation

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 implementationInterfaces cannot contain instance variables. However, they can contain public static final variables (ie. constant class variables)

• Interfaces are declared using the "interface" keywordIf 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

public interface Steerable{public void turnLeft(int degrees);public void turnRight(int degrees);

}

In Steerable.java:

public class Car extends Vehicle implements Steerable {public int turnLeft(int degrees){

[...]}

public int turnRight(int degrees){

[...]}

In Car.java:

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

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

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

In Car.java:

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;[...]

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 variablesThe 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 classWhen the subclass needs to inherit from another classWhen you cannot reasonably implement any of the methods

abstract-classes.ppt 17

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.



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



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



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



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



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.



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.


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” only particular shapes make sense, not generic ones if Shape is abstract, you can’t 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


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 can add these qualifiers if you like, but why bother?

you cannot instantiate an interface

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 interface but has only empty method bodies


the end

java interfaces & abstract classes

Education