Java：泛型中的不同接口

我有两个类（A和B）具有相同的方法（foo）：

我想创建一个可以调用这个方法的泛型类。但我有两个想法如何在运行时实现这一点，但对编译时没有任何想法：

检查类型并转换为A或B

获取方法

调用getMethod的泛型示例：

public class Template<T> {
 private T mT;

 public Template(T t) {
  mT = t;
 }

    public String bar() {
     String result = "no result";
  try {
      Method m = mT.getClass().getMethod("foo", null);
   result = (String)m.invoke(mT);
  } catch (Exception e) {
   result = e.toString();
   e.printStackTrace();
  }
  return result;
    }
}

公共类模板{
私人T-mT；
公共模板（T）{
mT=t；
}
公共字符串条（）{
String result=“无结果”；
试一试{
方法m=mT.getClass（）.getMethod（“foo”，null）；
结果=（字符串）m.invoke（mT）；
}捕获（例外e）{
结果=e.toString（）；
e、 printStackTrace（）；
}
返回结果；
}
}

还有别的办法吗？ 我在找这样的东西：

public class Template<T extends A | B> {
...
}

公共类模板{
...
}

---

请注意，我不是类“a”和“B”的创建者。

您必须使这两个类实现一个公共接口，声明foo方法。

---

Java不支持所谓的“duck类型”，这在这里会很有帮助

您必须使这两个类实现一个声明foo方法的公共接口。

---

Java不支持所谓的“duck类型”，这在这里会很有帮助

您可能只需要创建一个类ABAbstract作为a和B的父类型。 然后，您可以使用该类作为参数，或者使用通配符泛型并将其强制转换为ABAbstract。 您还可以让类A和B实现一个声明方法foo的接口。这可能是使您的编译不抛出任何错误并完全符合您所说的“您正在寻找”的最简单方法

但我想你必须写：

public class Template<T extends ABInterface> {

公共类模板{

但我不能肯定这一点。

---

它也可以实现，尽管类需要使用关键字implement。

您可能只需要将类ABAbstract作为a和B的父类型。 然后，您可以使用该类作为参数，或者使用通配符泛型并将其强制转换为ABAbstract。 您还可以让类A和类B实现一个声明方法foo的接口。这可能是使您的编译不会抛出任何错误并完全符合您所说的“您正在寻找”的最简单方法

但我想你必须写：

public class Template<T extends ABInterface> {

公共类模板{

但我不能肯定这一点。

---

它也可以实现，尽管类需要使用关键字implement。

您必须创建一个接口，并让模板接受实现该接口的任何类

interface Foo{
    public String foo();
}

public class A implements Foo {
    public String foo() {
        return "A said foo";
    }
}

public class B implements Foo{
    public String foo() {
        return "B said foo";
    }
}

public class Template<T extends Foo> {
    private T mT;

    public Template(T t) {
        mT = t;
    }
    public String bar() {
        return mT.foo();
    }
}

接口Foo{
公共字符串foo（）；
}
公共类A实现Foo{
公共字符串foo（）{
返回“A said foo”；
}
}
公共类B实现Foo{
公共字符串foo（）{
返回“B说福”；
}
}
公共类模板{
私人T-mT；
公共模板（T）{
mT=t；
}
公共字符串条（）{
返回mT.foo（）；
}
}

您必须创建一个接口，并让模板接受实现该接口的任何类

interface Foo{
    public String foo();
}

public class A implements Foo {
    public String foo() {
        return "A said foo";
    }
}

public class B implements Foo{
    public String foo() {
        return "B said foo";
    }
}

public class Template<T extends Foo> {
    private T mT;

    public Template(T t) {
        mT = t;
    }
    public String bar() {
        return mT.foo();
    }
}

接口Foo{
公共字符串foo（）；
}
公共类A实现Foo{
公共字符串foo（）{
返回“A said foo”；
}
}
公共类B实现Foo{
公共字符串foo（）{
返回“B说福”；
}
}
公共类模板{
私人T-mT；
公共模板（T）{
mT=t；
}
公共字符串条（）{
返回mT.foo（）；
}
}

确实如此。没有接口（或超类），唯一的方法是通过反射、泛型或否。确实。没有接口（或超类），唯一的方法是通过反射、泛型或否。我不是a和B类的创建者。我不是a和B类的创建者。