Today I'm going to talk about something you might have seen, but if you haven't, it's no big deal. It is the keyword abstract.
We use abstract as part of the definition of a class, which indicates that while it is in fact a valid class file, nobody is allowed to create an object of that type. That doesn't mean that it's useless though. Remember, we have inheritance on our side. You can create concrete classes (concrete is just the opposite of abstract, indicating a class from which you can create objects. No special keyword is needed for that) that extend abstract classes all you want.
We also use abstract as part of method signatures when we want to create the idea of a particular method call but wish to defer the actual implementation of said method to our concrete classes. This is similar in concept to interfaces, and sometimes it's more of a personal decision as to which you will use.
You see a lot of abstract classes in use when you look through frameworks, which are basically bodies of code designed to accomplish some function but with the details left up to the final developer. There are business frameworks, logging frameworks, GUI frameworks, reporting frameworks, the list is very long. Usually the trigger for creating a framework is when someone realizes they've just written the same thing for the fifth or tenth time, and that the differences between the various programs are relatively minor. Maybe you query a database, format a report and write it to a file, and it's always the same except for the details of which fields you look for and print.
This is a great application for abstract classes. Let's take a look at a simple one:
public abstract class Report {
}
Well, that's about as simple as it gets. To be fair it's also about as useless as it gets but never fear, we'll fill in some details later. Actually it's not entirely useless. You might want to have a set of classes that all share a common base class so that you can collect them into a Collection of some sort, although you could also make this work with an interface. Abstract classes really come into their own when you include some code within them. So let's write something.
public abstract class Report {
public abstract void GenerateOutputLine(String dataLine);
public abstract String ReadData();
public void runReport() {
String dataLine = null;
while( null != ( dataLine = ReadData() ) ) {
GenerateOutputLine(dataLine);
}
}
}
Let's write a simple test driver:
public class ReportTester extends Report {
public static void main(String[] args) {
ReportTester rt = new ReportTester();
rt.runReport();
}
"one", "two", "three", "four", "five"
};
int lineNumber = 0;
public void GenerateOutputLine(String dataLine) {
System.out.println(dataLine);
}
public String ReadData() {
String toReturn = null;
if (lineNumber < dataLines.length) {
toReturn = dataLines[ lineNumber++ ] ;
}
return toReturn;
}
}
Now if we were to run 'ReportTester' we'd get the output:
one
two
three
four
five
The main driver of the program is still in that 'Report' superclass, but the implementation details have been kept in ReportTester. We run the code in Report, and it calls the methods it finds in ReportTester to do the work. ReportTester itself is quite simple. In addition to a simple main that does nothing more that create ReportTester and run it (actually running that method from the superclass Report), it defines the specific implementations for our two abstract methods. One method does nothing more than write to the console and I hope I don't need to explain that. The other goes through an array of Strings, returning the next one in the array and increasing the index value each time it's invoked until it reaches the end of the list, at which time it returns a null which triggers the end of the loop in 'runReport'.
This is of course tremendous overkill for a program of this size, but as your projects get more involved, the ratio of abstract code to concrete code is likely to change quite a bit. System maintenance gets easier and faster, and your software gets more robust. After all, a bug fix to a framework may take care of issues across several dozen different specific implementations of different reports.
I will of course revisit this topic later, because we've only scratched the surface of the possibilities brought on by object orientation. With enough small components intelligently built, one can assemble new programs almost like putting together Tinker Toys or Lego. One's systems can be defined in large part by configuration files, and changed easily at will, all without writing, testing or deploying new code.
No comments:
Post a Comment