Creating objects from classes that implement interfaces in Java

Question

Possible Duplicate:
Why should the interface for a Java class be prefered?

In Java, is there a difference between these two lines? If so, what is it, and when should I use either one? Is there a preferred convention?

Note that ArrayList implements List.

List<String> bunchOfStrings = new ArrayList<String>();

ArrayList<String> bunchOfStrings = new ArrayList<String>();

and specific to the example: http://stackoverflow.com/questions/4062982/list-versus-arraylist — Paul Bellora, Sep 02 '11 at 16:53
@Kublai, if you click on my link, you'll see it's specific to this question as well. ;) — Kirk Woll, Sep 02 '11 at 16:54
@Kirk - yeah I meant in terms of the accepted answer. Just adding info. — Paul Bellora, Sep 02 '11 at 16:57

score 2 · Answer 1 · answered Sep 02 '11 at 16:52

In Java, is there a difference between these two lines?

Yes, there is a slight difference, and the List<String> variant is preferred.

Is there a preferred convention?

The convention says that you should "program against interfaces". The reason is that it becomes much easier to swap the actual implementation (in this case from ArrayList to say LinkedList).

score 1 · Answer 2 · answered Sep 02 '11 at 16:52

You should use the most generic type possible. So in this case that's List. The only time you would use a more specific type is if that type had methods defined on it that the more generic type does not.

The reason is that if a method accepts a type, like List, the user of the method can provide any type of List they want. If a method only accepts an ArrayList, the user can't use any other type of List.

score 1 · Accepted Answer · answered Sep 02 '11 at 16:53

In both case you are instantiating an ArrayList. The difference is that in the first case you are referring it as a List (the interface that ArrayList implements ), so you don't have access to specific method of ArrayList class, but only interfaces method.

use thi first:

List<String> bunchOfStrings = new ArrayList<String>();

This way you can switch different List implementation (ArrayList, Vector):

public class AClass(){
   List<String> bunchOfStrings;

   public List<String> getList(){
        bunchOfStrings = new ArrayList<String>();
        //or you can switch to : bunchOfStrings = new Vector<String>();
        return bunchOfString;
   }
}

Mansoor Siddiqui · Answer 4 · 2011-09-02T16:59:01.273

If you declare bunchOfStrings as a List, you can't call any of the ArrayList methods (without casting), even though it is pointing to an ArrayList object -- you can only call methods that are declared in the List class.

For this reason, you might think that it's better to always declare your variable type to be as specific as possible, but declaring it as a List is generally preferable because it allows you to change the underlying implementation of your List without having to change anything else in your code. You can easily modify your code as follows without breaking anything else in your code:

List<String> bunchOfStrings = new LinkedList<String>();

As a rule of thumb, only ever declare the type of your variable to be a specific subclass if you...

...need access to methods that are only available in the subclass.
...need to pass the object instance to a method that only accepts objects of that subclass.

score 0 · Answer 5 · answered Sep 02 '11 at 17:10

This is called Polymorphism. It is very useful and has no real drawbacks.

Pros:

You can send this instance variable to any method that wants a "List" object.

Using List in a method declaration, you are opening up the method to anything that is a sub-type of List, instead of just of type ArrayList.

Cons:

You would have to cast your variable to an ArrayList to access or set any features/methods/fields that are in ArrayList (but not in List). But those things are still available.

Creating objects from classes that implement interfaces in Java

5 Answers5