Inheritance and casting for List Objects

Question

I'm having trouble casting a List of Fruit down to the Fruit subclass contained in the List.

public class Response {
    private List<Fruit> mFruitList;
    public List<Fruit> getFruitList() {
        return mFruitList;
    }
} 

public class Fruit {
}

public class Orange extends Fruit {
}

List<Fruit> oranges = response.getFruitList();

How do I cast oranges so that it is a List of class Orange? Is this a bad design pattern? Basically I am getting a JSON Response from a server that is a List of Fruit. For each specific call to the Web Service, I know what subclass of Fruit I will get and so I need to cast that List appropriately.

Have you tried just `List oranges = (List) response.getFruitList();` ? — talnicolas, Jun 15 '11 at 16:34
Yes I've tried a lot of forced casting with no positive result. I'm re-considering my approach. Perhaps it's best to subclass Response and implement the appropriate List for each Fruit subclass. 90% of Response contains members that are identical for each Fruit class, except for the List. — Will Curran, Jun 15 '11 at 16:49

score 7 · Accepted Answer · edited Jun 15 '11 at 17:16

7

If you known for each specific call that what subclass of Fruit you will get then you should use generics instead of casting lists.

public class Response<T extends Fruit> {
    private List<T> mFruitList;
    public List<T> getFruitList() {
        return mFruitList;
    }
} 

Response<Orange> response = // create
List<Orange> oranges = response.getFruitList();

EDIT: By templates I meant generic types. Sorry, I had too much C++ nowadays

edited Jun 15 '11 at 17:16

Will Curran

6,959
15
59
92

answered Jun 15 '11 at 16:41

Zoltan Balazs

837
5
7

What precisely do you mean by templates? It is my understanding that Java does not have templates in the same way that say C++ does. – Michael McGowan Jun 15 '11 at 16:44
Ah interesting. Let me try this . . . – Will Curran Jun 15 '11 at 16:49

score 3 · Answer 2 · answered Jun 15 '11 at 16:37

3

The whole idea behind typecasts is to be able to tell the compiler, "Hey, I know more about this than you do." In your code, the compiler cannot safely downcast the List<Fruit> to List<Orange> because it can't know what the list will contain at runtime.

If you're absolutely certain that the list will be only Orange instances, and it makes your code more manageable to downcast, go for it.

List<Orange> oranges = (List<Orange>) response.getFruitList();

The compiler will give you a warning, of course, since you're doing something it thinks you shouldn't do. And just know that the JVM may have the last laugh by throwing a CastClassException if you were wrong!

answered Jun 15 '11 at 16:37

stevevls

10,675
1
45
50

Perhaps it would be better to subclass Response and implement the appropriate List for each corresponding Fruit subclass? – Will Curran Jun 15 '11 at 16:46
1

@Arch Stanton instead of subclassing `Response`, you could also generic-ize it. `public class Response { private List fruit; /* etc. */ }` – stevevls Jun 15 '11 at 16:50
@talnicolas ha...i hadn't seen your comment yet. great minds think alike. ;) – stevevls Jun 15 '11 at 16:51
Agreed. I last used Java before Generics were introduced and am beginning to wrap my head around them . . . – Will Curran Jun 15 '11 at 16:51

score 1 · Answer 3 · answered Jun 15 '11 at 16:54

Think of generics like a gate for what types of objects a list can contain. Because of this inheritance and casting won't work in the way you would expect. In the example you gave you could put both Oranges and Apples in your List<Fruit>. If the list has both apples and oranges how can you cast it to a List<Orange>.

If you need a List<Orange> then why even bother with the List<Fruit>. If you are explicitly casting it anyway and you know exactly what it contains its probably a needless abstraction.

If you are working with an API you can't change but you know exactly what it contains then you should loop through with an instanceof check just to make sure and explicity cast each Fruit instance to Orange when you need to the Orange API.

score 0 · Answer 4 · answered Jun 15 '11 at 16:34

0

You should cast List, and test if each elements are instanceof Orange, and after the test cast in Oranges. This is the "best pratice".

answered Jun 15 '11 at 16:34

Victor

8,309
14
80
129

score 0 · Answer 5 · answered Jun 15 '11 at 17:15

Given

List<Fruit> getFruits() {...}

You can't typecast

List<Orange> oranges = (List<Orange>) getFruits();

Due to type erasure, at runtime the type of getFruits is just List. The compiler will not even let you do the downcast (I was in doubt, so I tried in Eclipse before answering).

You could tell the compiler that your list will contain some subclass of Fruit, in that case, you need to use a wildcard on you method:

List<? extends Fruit> getFruits() {...}

Then the cast becomes possible, but with a type safety warning:

@SuppressWarnings("unchecked")
List<Orange> oranges = (List<Orange>) getFruits();

Given that the runtime type of getFruits is List, you can just discard the generics type information and use an unsafe assigment:

@SuppressWarnings("unchecked")    
List<Orange> oranges = (List) getFruits();

Maybe a more elegant way as it clearly states your intention, although requiring more system resources would be:

List<Orange> oranges = Arrays.asList((Orange[])getFruits().toArray())

Arrays in Java preserve their type information at runtime, so the cast is valid and "safe" from the compiler perspective, but it can throw a runtime exception if you pass some apples in the fruit basket.

Inheritance and casting for List Objects

5 Answers5