What's the differences between Array declaration and Collection declaration

Question

 1.  List<Car> carList = new ArrayList<Sedan>();

 2.  List<Car> carList = new ArrayList<Car>();
    carList.add(new Sedan());

1 has a compiler error and 2 is legal.

Why the type of variable declaration must match the type we pass to the object type(derived type is not allowed)? I was using Array as following which absolutely correct:

int SIZE = 10;
Car[] carArray = new Sedan[SIZE];

Can anyone tell me why collections must declare as condition 2? Thanks

[Java Generics](http://docs.oracle.com/javase/tutorial/java/generics/). — takendarkk, May 08 '14 at 16:38
@Takendarkk I know it is generics, but generics is talking about using angle brackets for the type, it's not about the super class and child class, isnt it? — Haifeng Zhang, May 08 '14 at 16:41
@haifzhan Do you really think super/child classes are not related to type? — takendarkk, May 08 '14 at 16:49
@Takendarkk Im not saying super and child classes are not related to type, I am asking you why they are related to Generics, and Im expecting an answer — Haifeng Zhang, May 08 '14 at 16:56
The array implementation is widely considered a mistake that was thankfully not repeated with Collections — Richard Tingle, May 08 '14 at 16:56

score 5 · Accepted Answer · answered May 08 '14 at 16:45

Sedan[] is a sub-type of Car[]. But this has a very negative impact on type safety, because the following code is thus legal:

Sedan[] sedans = new Sedan[10];
Car[] cars = sedans; // legal, since Sedan[] extends Car[]
cars[0] = new Car(); // Houston, we have a problem

This code causes an ArrayStoreException at runtime, because an array supposed to only contain sedans would contain a non-Sedan car.

The goal of generics was to have type-safe collections. And the decision was thus taken to design them so that the above problem would be detected at compile time, rather than runtime. Collections are much more used than arrays, and it's quite a good thing to have them type-safe.

So they decided that a List<Sedan> would not be a List<Car>.

score 1 · Answer 2 · answered May 08 '14 at 16:44

In your Case 1, what you are essentially doing is creating an ArrayListto hold all sorts of car objects, then trying to assign this variable an ArrayList of Sedans. This will not work at its core because you are going from large to small (A Sedan is a Car, but a Car might not be a Sedan).

Basically, your carList in Case 1 can won't work because, with generics, any Car should be able to be put in carList. This means I can call carList.add(new Compact(); right after adding a Sedan.

Case 2 follows this convention.

The way I like to think about it when using generics is that you're essentially creating instances of two separate types of objects in Case 1. Imagine ArrayListCar and ArrayListSedan for a moment, if you will. Each is specialized to take their specific arguments. Confusing, I know, since the arrays will work, but that's just the way it's designed.

score 1 · Answer 3 · answered May 08 '14 at 16:51

It is about type safe in Generics. Assume it is okay:

List<Dog> dogs = new ArrayList<Dog>();
List<Animal> animals = dogs;
animals.add(new Cat());

you definitely can add a new cat object to a list of type Animal, but if the animals refers to dogs, you will messed up a cat with a bunch of dogs, and which is very dangerous, to avoid this, type safe of Generics only allow the declaration type match the object type.

score 1 · Answer 4 · answered May 08 '14 at 16:55

This article and this article explain it in detail. The main idea was explained by Josh Bloch using the PECS principle for generics

Producer Extends > Consumer Super  [PECS]

I most depends on how your are interacting with data stored in a container, as producer or consumer.

Another concern is when is type safety checked, run time or compile time.Consider the following:

// array type safety errors caught at run time
Object[] objArray = new Long[3];
objArray[0] = "i'm a string";
Object notANumber = objArray[0];

// run time exception
Long number = (Long)notANumber;

// generic type errors caught at compile time
// use pecs principle in new ArrayList<...>();
List<Number> list = new ArrayList<Number>();
list.add("not a number"); // compile time error
list.add(Long.valueOf(42L));

Long wontWork = list.get(0);  // compile time error
Number works = list.get(0);

score 0 · Answer 5 · answered May 08 '14 at 16:54

This compiles:

List<? extends Car> carList = new ArrayList<Sedan>();

but it will not behave as you expect, and the result may be confusing later on if you don't have a sufficient understanding of generics. You should really read a tutorial, there are many of them.

What's the differences between Array declaration and Collection declaration

5 Answers5