Question

I saw an example like this in a text and wasn’t sure why they did it this way. Let’s say you’re getting a bunch of Apple objects from a database:

List<Apple> appleList = (List<Apple>) db.getApples()

Why would you cast to a List<Apple> instead of one of the concrete List types (ArrayList, Vector or LinkedList)?

Answer 1

This wiki article on the Liskov Substitution Principle and the Interface Segregation Principle may help you understand why you should program to interfaces.

When working across domains which is common in EE development, you many times don’t care what kind of Collection is being used. You more often than not just want to retrieve something from it, iterate over it or remove something. None of these require knowing what kind of implementation you are dealing with. It will also make it easy to switch out the underlying implementation. For instance, let’s say that I am working on a project and load a list of items from a database into an ArrayList. Elsewhere in the code I am iterating through this list:

class DBUtil {
    public static ArrayList<Item> getMeAllOfMyItems() {
         return items; // load from database whatever...
    }
}

… meanwhile …

ArrayList<Item> items = DBUtil.getMeAllOfMyItems();
for (int i = 0; i < items.size(); i++) {
    // do something with item
}

Now let’s say that I decide to use a Linked List instead. I would have to change the method that loaded everything from the database, as well as the code I was using to iterate through it:

class DBUtil {
    public static LinkedList<Item> getMeAllOfMyItems() {
         return items; // load from database whatever...
    }
}

… meanwhile …

LinkedList<Item> items = DBUtil.getMeAllOfMyItems();
for (int i = 0; i < items.size(); i++) {
    // do something with item
}

That was two changes. If I had written it originally as:

class DBUtil {
    public static List<Item> getMeAllOfMyItems() {
         return items; // load from database whatever...
    }
}

… meanwhile …

List<Item> items = DBUtil.getMeAllOfMyItems();
for (int i = 0; i < items.size(); i++) {
    // do something with item
}

I would only had to change one method, the method where I am returning the items from the database.

Even better would be to change the way I am iterating over the items to use the for each style:

class DBUtil {
    public static List<Item> getMeAllOfMyItems() {
         return items; // load from database whatever...
    }
}

… meanwhile …

List<Item> items = DBUtil.getMeAllOfMyItems();
for (Item i : items) {
    // do something with item
}

Now if I wanted, I could even change out even more of the implementation and as long as whatever I use implements Iterable, I don’t even really care what type of Collection the underlying system is using.

You should strive to make things as generic as possible with the intent that you don’t want to have to change 3 or 4 files because of a small change elsewhere.