CODEWITHSUNDEEP
javaoop
Peanut
Peanut

Reputation: 2251

Passing in a sub-class to a method but having the super class as the parameter?

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
        }
    }
}

Upvotes: 41

Views: 46418

Answers (4)

not2savvy
not2savvy

Reputation: 4243

I have found this syntax to be working as expected:

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

Upvotes: 1

Don Rolling
Don Rolling

Reputation: 2339

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!

Upvotes: 0

DaveFar
DaveFar

Reputation: 7457

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);
      }  
  }
}

Upvotes: 3

mprivat
mprivat

Reputation: 21902

Do this instead:

public <T extends Vehicle> void exampleMethod(Class<T> type)

Upvotes: 76

Related Questions