获取类定义中泛型的参数化类型

Question

I am writing a class that takes in a parameterized type, which I am trying to parameterize.

So I have a User object which has an ID. I am making ID a parameterized type. I have a class called Router that needs to provide one method T route(List<T>); , where T extends User .

Within Router I have some utility methods where I need to group by an ID within User, which is also parameterized. So User looks like User<K> , where K is the type of ID. So I would have a method that looks like the following within Router:

public T route(List<T> listToRoute) {
  Map<K, Double> someUtilityMap = groupValueById(listToRoute);
  // apply some logic
  return chooseFinalCandidate(someUtilityMap);
}

Currently I have:

public class Router<K, T extends User<K>> {

Is there a cleaner way to get and reference K within Router without the callers having to provide it explicitly in instantiation? Can I somehow just give T and then use K in the Router implementation?

I need to reference K explicitly in code, so something like:

Map<K, Double> groupValueById(List<T> routingCandidates) {

What I would like to do is something like:

new Router<User<Integer>>();

as opposed to:

new Router<Integer, User<Integer>>();

Answer 1

I would suggest you to change the signature or your class to public class Router2<K> .

Currently, I understand, you have something like

public class Router<K, T extends User<K>> {
  Map<K, Double> groupValueById(List<T> routingCandidates) {
    return null;
  }
}

Then call it like

List<User<Integer>> list = new ArrayList<>();
Router<Integer, User<Integer>> router = new Router<>();
Map<Integer, Double> map = router.groupValueById(list);

You can change it to something like

public class Router<K> {
  <T extends User<K>> Map<K, Double> groupValueById(List<T> routingCandidates) {
    return null;
  }
}

and call it like

List<User<Integer>> list = new ArrayList<>();
Router<Integer> router = new Router<>();
Map<Integer, Double> map = router.groupValueById(list);

Although it might seem that we only move the problem to another place, it makes it much simpler to use the class, because you do not need to write down the generic type parameters when using the method.

I think there are two concepts here, that have to be kept separated:

1. The type parameter of the class
2. The type that the class operates on

The only varibale type that is not known in advance and that has to be filled in is K . When you know K , you can derive User<K> from it. User is always the same. So this class should have only one type parameter: K . This is sufficient for defining the concrete classes.

The class operates on objects of type User<K> . You try to express this by type parameters, but this is not what generics are made for. I do not know of a way to capture the K from User<K> and I think it is not necessary here. It would only make the definition more complicated than necessary.