Abstract Classes Versus Interfaces
As a final note, I think it would be worthwhile to add a quick little section about abstract classes and interfaces.
This section is based on a question I received last week along the lines of:
> when do you make a class Abstract?
> when do you define an interface?
> what is the difference between Abstract class
> and interface?
An abstract class is a special type of Java class that has the following characteristics:
- Abstract classes cannot be instantiated as objects.
- Abstract classes are usually used as superclasses from which to derive inherited classes that can be instantiated.
- Abstract classes usually contain base implementations of methods that all derived classes need or want.
I think the best way to understand an abstract class is by way of a real world example.
Consider a Mammal class.
As you might recall from your years in primary school, all mammals share various methods and properties such as the fact that they are warm-blooded, maintain homeostasis, and have hair.
However, it would not exactly make sense to instantiate a mammal object from the mammal class.
Think about it, in the real world there really aren't any plain, vanilla mammals.
Rather, there are "animals that are of the mammal class by inheritance" such as dogs, whales and people.
But straight mammals...there aren't any in nature.
(Rule 1: Abstract classes are not instantiated as objects).
Mammal is more of a category than a thing.
It is a conceptual tool used to define characteristics shared by a set of objects.
It is an organizational tool defining a hierarchy.
(Rule 2: Abstract classes are used from which to derive inherited classes)
However, Mammal is not simply an organizational tool.
It has value in that it does do work.
The Mammal class does define methods and properties.
As a result, inherited classes like dog, whale , and person do not need to do the work.
(Rule 3: Abstract classes usually contain base implementations of methods that all derived classes need or want.)
So what good are abstract classes to you as a programmer?
Well, they are really a convenience tool that you can use when you develop object libraries.
Abstract classes give you the ability to define a class from which you will derive a set of classes when you want them all to inherit a set of functionality.
Thus they provide you a way to implement a set of methods and/or properties that all derived classes will inherit.
However, it is crucial to be clear that the abstract class itself is never used by itself.
I like the example that is given by Barry Boone in his Java 2 Exam Guide.
"Imagine a class called Transaction that is to be used in a home banking application.
This class has two subclasses: Deposit and Withdrawal.
It might not make sense to create an instance of Transaction; a customer doesn't generically announce to the bank teller, 'I want to make a transaction', but rather 'I want to make a deposit' or 'I want to make a withdrawal'."
I think that Barry could go one step further.
Not only does it not make sense to create a Transaction object, it might even be something that you want to discourage as the developer of an object library.
By declaring the class as abstract you force other programmers to maintain your sense of how the hierarchy works.
An interface is like an abstract class in that interfaces are not instantiated into objects.
However, the similarity pretty much stops there.
Interfaces are not primarily concerned with defining a superclass from which to derive subclasses.
Similarly, interfaces do not contain base implementations to be used by subclasses.
Instead, an interface defines a set of "unimplemented" methods that some other object must implement in order to claim the title "official implementor of the interface"
Interfaces are essentially contracts that specify that any object that claims to implement the interface agrees to implement the set of methods defined by the interface.
Once an implementor has implemented the methods, any other object in the application can trust that the implementor has in fact implemented the methods defined by the interface.
Like abstract classes, interfaces are constructs to help programmers keep object libraries controlled and to enforce standardization on further development by other programmers.
They are there to help you maintain high coding standards.
NEXT
Selena Sol contributes to the JavaBoutique's Introduction to Java. Selena curently works for Barclays Capital in London, one of the leading global investment banks in Europe and has worked as a software developer for the National Center for Human Genome research, Microline Software, Neuron Data, and Electric Eye in Singapore. Selena is perhaps best-known for creating the Public Domain Web Script Archive (Extropia) and writing several books on Web Programming (Perl, CGI, Java).
Email: selena@extropia.com
| 
