42

I have an abstract class Vehicle with 2 implemented subclasses RedVehicle and YellowVehicle.

In another class I have a List<Vehicle> containing instances of both subclasses. I want to be able to pass into a method a class type and then use that type to decide which set of objects I want to do something to in the List.

Since Class is generic I should parameterise it with something, however putting the parameter as the parent class Vehicle stops the calling code working since exampleMethod is now expecting a type of Vehicle, not a subclass of RedVehicle or YellowVehicle.

I feel there should be a clean way to do this so what would be the correct way to implement the functionality?

n.b. I don't necessarily have to pass in the Class type, if there are better suggestions I'd be happy to try those.

Calling code:

service.exampleMethod(RedVehicle.class); service.exampleMethod(YellowVehicle.class);

Fields/Method:

//List of vehicles //Vehicle has 2 subclasses, RedVehicle and YellowVehicle private List<Vehicle> vehicles; //Having <Vehicle> as the Class parameter stops the calling code working public void exampleMethod(Class<Vehicle> type) { for(Vehicle v : vehicles) { if(v.getClass().equals(type)) { //do something } } }
Improve this question

4 Answers 4

Reset to default
77

Do this instead:

public <T extends Vehicle> void exampleMethod(Class<T> type)
Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

I knew it would be something simple. Is there a special name for having the generic type before the return type/a link to a general source would be nice. I'll try and tomorrow and accept if it works thanks.
have a look at oracle's generics introduction or angelika langer's java generics FAQ. +1 for mprivat's direct solution.
@DaveBall Thanks for the angelika langer suggesetion, I'm aware of generics as a concept and have used them but have never looked at them in depth, this looks like a great in-depth discussion of them. The link for anyone else interested: angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html
A little elaboration of this answer can be found here
@Peanut They are called generic methods
|
3

Why don't you use the visitor pattern?

That way you

  • don't need type tokens
  • let dynamic dispatch handle the case distinction (instead of if(v.getClass().equals(type)))
  • are more flexible (following OCP)

In detail:

your abstract class Vehicle gets a method accept(Visitor v), with the subclasses implementing it by calling the appropriate method on v.

public interface Visitor { visitRedVehicle(RedVehicle red); visitYellowVehicle(YellowVehicle yellow); }

Using a visitor:

public class Example { public void useYellowOnly() { exampleMethod(new Visitor() { visitRedVehicle(RedVehicle red) {}; visitYellowVehicle(YellowVehicle yellow) { //...action }); } public void exampleMethod(Visitor visitor){ for(Vehicle v : vehicles) { v.accept(visitor); } } }
Improve this answer

Comments

1

I have found this syntax to be working as expected:

public void exampleMethod(Class<? extends Vehicle> type)
Improve this answer

Comments

0

The accepted answer works and got me where I wanted to go. I thought I would add this just to make it clearer to anyone who might need it.

In this case RevisedExposure is a sub-class of Exposure. I need to call GetMetadata() with a list of either of these, which results in the same result set.

private async Task<List<Metadata>> GetMetadata<T>(List<T> exposures) where T : Exposure

Now I can call this method from two places with different versions of the list like this.

var metadata = await GetExposureMetadata(revisions);

or

var metadata = await GetExposureMetadata(exposures);

works great!

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.