Interfaces and Abstract Classes
Interface
// I say all motor vehicles should look like this:
interface MotorVehicle
{ void run(); int getFuel(); }
// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{
int fuel;
void run()
{ print("Wrroooooooom"); }
int getFuel() { return this.fuel; }
}
Interfaces
• An interface is a contract: The person writing
the interface says, "hey, I accept things looking
that way", and the person using the interface
says "OK, the class I write looks that way".
• An interface is an empty shell. There are only
the signatures of the methods, which implies
that the methods do not have a body. The
interface can't do anything. It's just a pattern.
Interface
• Implementing an interface consumes very
little CPU, because it's not a class, just a bunch
of names, and therefore there isn't any
expensive look-up to do. It's great when it
matters, such as in embedded devices.
Abstract classes
• Abstract classes, unlike interfaces, are classes.
They are more expensive to use, because there is
a look-up to do when you inherit from them.
• Abstract classes look a lot like interfaces, but
they have something more: You can define a
behavior for them. It's more about a person
saying, "these classes should look like that, and
they have that in common, so fill in the blanks!".
Abstract Classes
// I say all motor vehicles should look like this:
abstract class MotorVehicle {
int fuel;
// They ALL have fuel, so lets implement this for everybody.
int getFuel()
{ return this.fuel; }
// That can be very different, force them to provide their // own
implementation.
abstract void run(); }
// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{ void run() { print("Wrroooooooom"); } }
Difference between abstract class and
interfaces.
• Abstract classes can have constants, members, method stubs
(methods without a body) and defined methods, whereas
interfaces can only have constants and methods stubs.
• Methods and members of an abstract class can be defined
with any visibility, whereas all methods of an interface must
be defined as public (they are defined public by default).
• When inheriting an abstract class, a concrete child class must
define the abstract methods, whereas an abstract class can
extend another abstract class and abstract methods from the
parent class don't have to be defined.
Difference between abstract class and
interfaces.
• Similarly, an interface extending another interface is not
responsible for implementing methods from the parent
interface. This is because interfaces cannot define any
implementation.
• A child class can only extend a single class (abstract or
concrete), whereas an interface can extend or a class
can implement multiple other interfaces.
• A child class can define abstract methods with the same
or less restrictive visibility, whereas a class implementing
an interface must define the methods with the exact same
visibility (public).
Difference between abstract class and
interfaces.
