在Java中从泛型方法调用重载方法

Question

我有一个Foo和Bar对象的列表，以及每个相应对象的转换器。

public static void Convert(Foo1 a, Bar1 b) {
...
}
public static void Convert(Foo2 a, Bar2 b) {
...
}
etc

Convert-method需要有所不同，因为Bar1与Bar2和Bar3等有很大不同，但是我想创建一个方法来处理所有可能的列表。

是否可以创建一个泛型方法，根据列表的内容调用相应的非泛型方法？

到目前为止，我已经尝试过了：

public static <T, S> void ConvertList(List<T> list, List<S> libList) {
    list = new ArrayList<T>(libList.size());

    for (int i = 0; i < libList.size(); ++i) {
        Convert(list.get(i), libList.get(i));
    }
}

但这并不能编译，因为"无法解析方法'Converts（T， S）'"

有什么想法吗？

Answer 1

您必须使用运行时多态来实现这一点。

第一步：创建代表每种类型的接口。

public  interface Foo<T> {
    public void convert(T bar);
}
public interface Bar<T> {
    public void convert(T foo);
}

第2步：创建实现类。

public class Foo1 implements Foo<Bar1> {

    @Override
    public void convert(Bar1 bar) {
        System.out.println("Foo1, Bar1");
    }
}
public public class Bar1 implements Bar<Foo1> {

    @Override
    public void convert(Foo1 foo) {
        System.out.println("Foo1, Bar1");
    }
}
public class Foo2 implements Foo<Bar2> {

    @Override
    public void convert(Bar2 bar) {
        System.out.println("Foo2, Bar2");
    }
}
public class Bar2 implements Bar<Foo2> {

    @Override
    public void convert(Foo2 foo) {
        System.out.println("Foo2, Bar2");
    }
}

第3步：创建函数，根据列表中的实例调用convert方法。

public static <T extends Foo, S extends Bar> void convertList(List<T> list,
        List<S> libList) {

    for (int i = 0; i < libList.size(); ++i) {
        list.get(i).convert(libList.get(i));
    }
}

第4步：创建样本列表数据并进行测试

    List<Foo<?>> listOfFoos = new ArrayList<Foo<?>>();
    List<Bar<?>> listOfBars = new ArrayList<Bar<?>>();
    listOfFoos.add(new Foo1());
    listOfFoos.add(new Foo2());
    listOfBars.add(new Bar1());
    listOfBars.add(new Bar2());
    convertList(listOfFoos,listOfBars);

Answer 2

不，你不能这样做——重载是在编译时确定的，听起来你希望根据所涉及对象的执行时间类型调用不同的方法，或者至少根据执行时间类型t，这在执行时是完全未知的。

基于执行时类型的代码路径决策通常通过重载重写来处理，但不清楚这在这种情况下是否可行。如果你能把一个适当的转换方法在每个Foo？？子类，您可以相应地约束T和S，但基本上有太多的上下文我们目前不知道。

您可以在执行时使用反射来查找和调用最合适的方法，但是这对代码来说是痛苦的，并且可能要慢得多。