java泛型参数不能应用于特定类型

Question

public class Demo {
    public String work(String s) {
        return s;
    }

    public <T> T Test(T t) {
        // common work to do !!
        // .....
        // spec work to do 
        T result = work(t);
        return result;
    }
}

Test() has some common work to do first, then specific work with respect to different type of T. The code above causes compiler errors, how can i do this ? thanks very much !

Answer 1

There are a number of things that can cause your code not to compile here; aside from the ';', you are returning something from a void method. Kindly post the compiler errors you're facing too, it will make things much clearer to potential responders.

Answer 2

What you could possibly get away with is to create a mapping from type T to a ( unary ?) function . Then, in the test method you can look-up the type T . If a function is registerede, apply:

public class Demo {
  private static final Map<Class<?>, UnaryOperator<?>> typeFuncs = new HashMap<>();
  static {{
    addTypeFunc(String.class, (String s) -> s); // Anonymous function.
    addTypeFunc(Integer.class, Demo::workInteger); // Function reference.
  }}

  private static <T> void addTypeFunc(Class<T> type, UnaryOperator<T> func) {
    typeFuncs.put(type, func);
  }

  private static Integer workInteger(Integer i) {
    return i;
  }

  public <T> T test(T t) {
    // common work to do !!
    // .....

    T result = null;
    UnaryOperator<T> operator = (UnaryOperator<T>) typeFuncs.get(t.getClass());
    if (operator != null) {
      result = operator.apply(t);
    }

    return result;
  }
}

Do note that the cast (UnaryOperator<T>) in test is only safe as we have total control of the relation between key and value types in the typeFuncs map.

Answer 3

Another approach is to use reflection. Do note that reflection is a powerful tool but it comes at a cost (performance.) Perform measurements to see whether this is a viable solution is your specific case:

public class Demo {
  private String work(String s) {
    return s.toUpperCase();
  }

  private Boolean work(Boolean b) {
    return !b;
  }

  public <T> T test(T t) {
    // common work to do !!
    // .....

    // Now look-up "work" method for type T. Invoke if defined.
    T result = null;
    try {
      Class<T> tType = (Class<T>) t.getClass();
      Method work = Demo.class.getDeclaredMethod("work", tType);
      if (work.getReturnType() != tType) {
        throw new NoSuchMethodException("No `work` method for type: " + tType);
      }

      result = (T) work.invoke(this, t);
    } catch (NoSuchMethodException e) {
      // NOOP - or whatever.
    } catch (IllegalAccessException | InvocationTargetException e) {
      // Method invocation failed. Handle properly.
      e.printStackTrace();
    }

    return result;
  }
}