Well, I'm going to get deeper into just what interfaces provide for you, and why you should both create and use them in a later post, but a simple example can be shown with the very common Collections interface "List".
Using List is very common, although a lot of people will begin using ArrayList directly. It's not that there's anything precisely wrong with doing this, In fact, probably nine or more out of ten times the only thing it will cost you is a few extra keystrokes. However, it serves as a good example in a section of code with which many of us get familiar early.
Suppose I wanted to have a list of active elements for a game. I could write this code to have it available within my GameData class:
private ArrayList<GameElement> gameElements = new ArrayList<GameElement>();
And then I could have a getter method:
public Arraylist<GameElement> getGameElements() {
return gameElements;
}
That's simple enough, right? So I go ahead and write a bunch of code within the rest of my game, happily accessing all the elements they need to function:
public void addElementToGame(GameElement newElement) {
ArrayList<GameElement> allElements = myGameData.getGameElements();
if (false == allElements.contains(newElement) {
allElements.add(newElement);
}
}
...
public void walkAllElements(ElementChecker myChecker) {
ArrayList<GameElement> allElements = myGameData.getGameElements();
for(GameElement element : allElements ) {
myChecker.checkElement(element);
}
}
etc. etc. etc.
It's not that there is anything wrong with this. In fact, you're feeling pretty good, you even made a method that accepts a worker object as a parameter and invokes some code on that worker object for each item in the list.
Then the reports start coming in: Sometimes the game gets very slow. It's generally after someone has been playing for a long time. Eventually, you pin it down to your element management code. It's fine with a few elements but once you get to having hundreds, certain operations get bogged down. At the same time, you realize that you'd love to prioritize these game elements by allowing inserts to happen at the start of the list for faster processing. That's got you down all weekend as you try to figure out what to do.
The light at the end of the tunnel comes when you review the documentation for the Collections framework and discover LinkedList. It might be a bit slower with smaller amounts of data, but it sounds like it will behave better for you with the large data sets you're processing and it offers the side benefit of being able to easily handle quick inserts at the start of the list.
That's when you suddenly get annoyed. You make the change in GameData and from all the red markers that show up on your screen you realize that you've got seven hundred and fifty places in your code base where you have to do nothing more than change the word 'ArrayList' to the word 'LinkedList'. This is all fixable, but it's going to take up a significant chunk of your time. Most of the code does not even have to change in any other way, maybe you've got two or five places where you will need to explicitly refer to methods that are specific to LinkedList, bu the rest are just mechanical updates of the code.
This is where coding to the interface could have saved you some time and effort. If, instead of referring to 'ArrayList' everywhere, you had just used 'List', all or at least most of your code would have otherwise remained exactly the same.
The declaration of gameElements could have been written this way:
private List<GameElement> gameElements = new ArrayList<GameElement>();
public void walkAllElements(ElementChecker myChecker) {
List<GameElement> allElements = myGameData.getGameElements();
for(GameElement element : allElements ) {
myChecker.checkElement(element);
}
Note that nothing has really changed here except for changing 'ArrayList' to 'List' in some places. This is because 'List' is an interface, which is really a kind of contract. It forces an object that implements it to support a set of defined methods, and both ArrayList and LinkedList do this.
public class ArrayList implements List {
public class LinkedList implements List {
Now this just scratches the surface of interface usage. Later on we'll get into creating and using your own, and how that can save you even more time and energy, and bring your coding to a new level. For now though, just be aware that classes can implement interfaces, and that whenever possible, it's better to write your code to care only about said interfaces, and not to give a hang about the specific object type it's dealing with. Get used to it, let it become your natural way of operating. It will serve you well later on. Eventually you will be creating your own interfaces, which can serve as the control points for widely varying objects. I can drive a car from any manufacturer, because they all offer me the same set of controls. I do not need to be licensed to drive a Subaru, separately licensed to drive a Volvo, and have a learner's permit for a Ford. Interfaces are like specifying 'gas pedal, brake pedal, steering wheel'. Oh, and objects can support arbitrary numbers of interfaces, so in reality my car is defined something like this:
public class S60 implements Driveable, GasPowered, Geartronic, PushbuttonStart, KeylessEntry {
There would no doubt be a lot more if I sat down to think about it all. The point is, once I understand how to drive a car, I can drive pretty much any car, because they ALL implement Driveable. If I go to my local Avis and rent something, I may not know about all the features, the navigation system may be a complete mystery to me, but man, I know how to work a steering wheel.
No comments:
Post a Comment