Java Generics - argument type and casting

Question

I have a generics problem I am trying to resolve. I'm doing some manual casting and it feels like I'm doing something wrong. I'm a bit new to using generics, so it's very much possible I am misusing them in some capacity. Some guidance would be very much appreciated.

TLDR:
I have an interface with a generic method that takes a T argument. I'm implementing this interface in a class, but in the implementer I would like to ensure T is of a specific type (lets say Animal so I can extract some fields). How can I do that?

Details:
I have an interface Transformer below, and an implementing class where SpecialTransformer implements Transformer.

Transformer has this definition:

public interface Transformer
  public <T> Event transform(T input);

whereas SpecialTransformer has this definition:

public class SpecialTransformer implements Transformer

  @Override
  public <T> Event transform(T input) {
    Animal convertedInput = (Animal) input; // <------- This feels wrong

    String color = convertedInput.getColor();
    //Other field based logic
  

  }

T extends Animal?

chrylis -cautiouslyoptimistic-
– chrylis -cautiouslyoptimistic-

2021-05-02 14:23:25 +00:00
Commented May 2, 2021 at 14:23 — chrylis -cautiouslyoptimistic-
– chrylis -cautiouslyoptimistic-, Commented May 2, 2021 at 14:23

Mark Rotteveel · Accepted Answer · 2021-05-03 08:07:16Z

5

Instead of putting the generics constraint on the method, you should put the constraint on the interface (and the class):

public interface Transformer<T> {
  Event transform(T input);
}

and on the class you either put a new generic type constrained to Animal and its sub-classes (or implementations):

public class SpecialTransformer<T extends Animal> implements Transformer<T> {

  @Override
  public Event transform(T input) {
    String color = input.getColor();
    //Other field based logic
  }
}

Or even plainly use Animal as the type to Transformer:

public class SpecialTransformer implements Transformer<Animal> {

  @Override
  public Event transform(Animal input) {
    String color = input.getColor();
    //Other field based logic
  }
}

You cannot achieve the same effect with the constraint on the method, because a method with signature <T> Event transform(T input) cannot be overridden by <T extends Animal> Event transform(T input), because this would be the equivalent of overriding a method transform(Object input) by transform(Animal input) which does not meet the interface contract.

On the other hand, if you expect all your Transformer implementations to accept Animal, then you could use <T extends Animal> Event transform(T input) in your interface (or public interface Transformer<T extends Animal> in my suggested form).

edited May 3, 2021 at 8:07

answered May 2, 2021 at 14:28

Mark Rotteveel

110k241 gold badges160 silver badges233 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

thebighoncho Over a year ago

Thank you so much for your detailed response. It turns out I was on the right track, but got confused in terms of the specific Syntax I needed to use. Your clarification really helped, thanks again Mark!

Collectives™ on Stack Overflow

Java Generics - argument type and casting

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related