Reason for - List list = new ArrayList();

Question

I have seen code like this many times: `List list = new ArrayList();` Why do people take the parent of `ArrayList` (and other classes) instead of the type of the generated object? Does that take less performance? Or why should someone do this?

Accepted Answer

When someone writes code like this, he/she is trying to follow a basic OO design principle which says -

Program to an interface, not to a concrete implementation

I have explained this principle in one of my blog posts. Look in the `Class Inheritance VS Interface Inheritance` section.

To summarize the post, when you use a reference of a parent type to refer to an instance of a sub-type, you get a lot of flexibility. For example, if you ever need to change your sub-type implementation in the future, you will be able to do that easily, without changing much of your code.

Consider the following method -

```
public void DoSomeStuff(Super s) {
    s.someMethod();
}
```

and a call to this method -

```
DoSomeStuff(new Sub());
```

now, if you ever need to change the logic inside `someMethod`, you can easily do it by declaring a new subtype of `Super`, say `NewSubType`, and changing the logic inside that implementation. In this way, you will never have to touch other existing code which utilizes that method. You will still be able to use your `DoSomeStuff` method in the following way -

```
DoSomeStuff(new NewSubType());
```

Had you declared the parameter of `DoSomeStuff` to be of `Sub`, you would then have to change its implementation too -

```
DoSomeStuff(NewSubType s) {
    s.someMethod();
}
```

and it may also chain/bubble to several other places.

In terms of your collection example, this lets you change the list implementation that a variable is pointing to without much hassle. You can easily use a `LinkedList` in place of an `ArrayList`.

Reason for - List list = new ArrayList();

Solution

Problem

Related problems