Question

情况：

我想编写如下通用函数：

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

问题： 我想给do（）函数提供两个不同类的实例。这两个类都来自一个设计糟糕的图书馆。这两个类都有一个something（）方法。但是他们没有实现相同的接口或扩展相同的超类。

我的第一个：

我可以这样写：

if(para instanceof A){
    ((A)para).something();
else if(para instanceof B){
    ((B)para).something();
}

我想这会有用，但我需要更频繁地调用某些东西（）并且不希望用if / else传播我的代码。谁有一个好线索？提前谢谢！

Answer 1

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

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();
}

正如评论中所提到的，不扩展A和B可能更好，但在包装类中保留A和B的实例变量：

public class C implements SomeInterface {

        private A a;
        public C(A a) { this.a = a; }

        @Override
        public void doSomething() {
            a.something();
        }
}

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

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

Answer 2

扩展和界面方法：

data want ;
  merge have(drop=var3 var4)
        have(keep=id var3 where=(not missing(var3)))
        have(keep=id var4 where=(not missing(var4)))
  ;
  by id;
run;

或者像包装器的评论中提到的那样：

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();

在泛型函数中使用类方法

2 个答案: