Java 在泛型函数中使用类方法

情况：

我想编写一个通用函数，如下所示：

public <T> void do(T para){
   para.something();
}

---

我想这是可行的，但我需要更频繁地调用something（），并且不想用if/else来垃圾邮件我的代码。有人有好的线索吗？提前谢谢

由于无法更改现有库，您可以创建自己的界面：

public interface SomeInterface {
    void doSomething();
}

public class C extends A implements SomeInterface {
    @Override
    public void doSomething() {
        this.something();
    }
}

public class D extends B implements SomeInterface {
    @Override
    public void doSomething() {
        this.something();
    }
}

public <T extends SomeInterface> void do(T param) {
    param.doSomething();
}

此外，对于Java 8，这可能是一个更简单的解决方案：

@FunctionalInterface
public interface SomeInterface {
        void doSomething();
}
public <T extends SomeInterface> void do(T param) {
    param.doSomething();
}
do(p -> a.something());

@functioninterface
公共接口{
无效剂量（）；
}
公共无效do（T参数）{
参数doSomething（）；
}
做（p->a.某事（））；

扩展和接口方法：

public interface ISomething {
    public void mySomething();
}

public ExtendA extends A implements ISomething {
    public void mySomething() { something(); }
}

public ExtendB extends B implements ISomething {
    public void mySomething() { something(); }
}

或者类似于使用包装器的注释中提到的：

public interface ISomething {
    public void something();
}

public WrapperA implements ISomething {
    private A a;

    WrapperA(A a) {
       this.a = a;
    }

    public void something() {
        return a.something();
    }
}

public WrapperB implements ISomething {
    private B b;

    WrapperB(B b) {
       this.b = b;
    }

    public void something() {
        return b.something();
    }
}

A instanceOfA = ...;
ISomething some = new Wrapper(instanceOfA);
some.something();

另一种方法是反射，它不如我认为的其他方法快：

A instanceOfA = ...;
methodName = "something";
Method somethingMethod = instanceOfA.getClass().getMethod(methodName);
somethingMethod.invoke(instanceOfA);

---

将

something（）

方法放在类

A

和

B

实现的接口中，并绑定泛型：

public…

@AndyTurner这两个类都来自库正如我提到的：A和B来自库。我不想更改这些代码。然后将

A

和

B

类封装在实现您自己的接口的东西中，并让这些封装器调用

something（）

方法。我想知道

@functionanterface

在这里是否有用-如果您只对这两种方法中的一种感兴趣，您可以让

do

方法接受该接口，并在使用该方法时传递一个方法引用（例如

do（someObject:：something）

。有人在这里看到明显的缺点吗？您更快；@Bene看起来不错。问题是，我不是自己创建实例的。它们是从库中返回的值。为什么功能接口更好？我仍然需要创建包装器类，并且仍然需要一个泛型函数。我看不出有什么好处。你不再需要包装器类了。只需使用lambda表达式调用泛型方法。您还可以将该方法设置为非泛型，并使用SomeInterface作为参数的类型。没有时间尝试，但应该双向工作。扩展边界不是必需的。扩展是个好主意吗？还是做包装纸更好？我认为最好再多加解释。@Kevin Wallis看起来不错。问题是，我不是自己创建实例的。它们是库中的返回值。我考虑过反射，但我没有选择。我应该在问题中提到这一点，对不起。好的：）（答案显示了不同的方式，也许其他人可以使用它们）

public interface ISomething {
    public void something();
}

public WrapperA implements ISomething {
    private A a;

    WrapperA(A a) {
       this.a = a;
    }

    public void something() {
        return a.something();
    }
}

public WrapperB implements ISomething {
    private B b;

    WrapperB(B b) {
       this.b = b;
    }

    public void something() {
        return b.something();
    }
}

A instanceOfA = ...;
ISomething some = new Wrapper(instanceOfA);
some.something();

A instanceOfA = ...;
methodName = "something";
Method somethingMethod = instanceOfA.getClass().getMethod(methodName);
somethingMethod.invoke(instanceOfA);