Superclass type or subclass type

Question

What is the difference of

LinkedList<String> l1 = new LinkedList<String>();
List<String> l2 = new LinkedList<String>();

Why does l2 type don't have method addFirst while l1 type have method addFirst? even though they are both hold a LinkedList object? Contrary to what I read from Gosling's "The Java Programming language" which states that the object will be what you made it to be, in this case I made it a LinkedList with new LinkedList() even though it is of type List

How should I properly declare then?

Collection<String> c = new LinkedList<String>();
List<String> c = new LinkedList<String>();
LinkedList<String> c = new LinkedList<String>();

score 8 · Accepted Answer · answered Jul 08 '13 at 10:40

Why does l2 type don't have method addFirst while l1 type have method addFirst?

Because the compile-time type of l2 is just List<E>, and List<E> doesn't declare the addFirst method.

As a simpler example, consider:

Object x = "hello";
int invalid = x.length(); // This is invalid

At execution time, x will refer to a String object, but the type of the variable itself is just Object, so you can't call the String.length() method.

It's very important to distinguish three different terms here:

A variable, which has a type based on how it's declared
A reference (e.g. the value of a reference-type variable)
An object (which has a type)

The value of a variable (assuming it's not a primitive variable) is a reference. That reference can either be null, or it can refer to an object of a type which is assignment-compatible with the type of the variable.

So in the above example:

The type of x is Object
The value of x is a reference
That reference refers to an object of type String at execution time

Thanks for your answer! So you mean... I should always make sure that the type during compile-time should complement with the object pointed to by the reference during the execution time. — krato, Jul 08 '13 at 12:05

score 1 · Answer 2 · answered Jul 08 '13 at 10:41

LinkedList<String> l1 = new LinkedList<String>();

Here l1 is the instance of LinkedList

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

Here l2 is the instance of List

l2 does not have method addFirst because List interface does not contain that method while LinkedList contains that. But anytime in your code, you can cast your l2 to linkedList and can call addFirst() method.

score 0 · Answer 3 · answered Jul 08 '13 at 10:51

List l2 = new LinkedList();

This is useful when You have a method that only takes an instance of SuperClass. Since SubClass is a SuperClass, you can use an instance of SubClass and treat it as SuperClass.

That's polymorphism. It allows you to change out the implementation of the class' internals without breaking the rest of your code.

Superclass type or subclass type

3 Answers3