如何围绕已经存在但无法在java中修改的类创建接口

假设我的代码中已经有2个类：

class SomeOrder {
  String getOrderId() { return orderId; }
}

class AnotherOrder {
  String getOrderId() { return orderId; }
}

如何围绕这两个类创建接口，即：

interface Order {
    String getOrderId();
}

理想情况下，我会修改代码，以便

SomOrder实现Order

和

AnotherOrder实现Order

，但这里的问题是它们属于我无法控制或编辑的包（即它们来自外部jar）

我的算法目前如下所示：

void sorter(List<SomeOrder> orders) {
    ... <custom sort logic> ...
    someOrder.getOrderId();
}

void sorter(List<AnotherOrder> orders) {
    ... <custom sort logic> ...
    someOrder.getOrderId();
}

void分拣机（列出订单）{
...  ...
getOrderId（）；
}
空分拣机（列出订单）{
...  ...
getOrderId（）；
}

使用单个接口，我可以编写：

void sorter(List<Order> orders) {
        ... <custom sort logic> ...
        order.getOrderId();
}

void分拣机（列出订单）{
...  ...
getOrderId（）；
}

您可以使用适配器类：

class SomeOrderAdapter implements Order {
    private SomeOrder delegate;

    @Override
    public String getOrderId() {
        return delegate.getOrderId();
    }
}

---

与另一个订单类似，因为您的接口是一个功能性接口，您可以为每个不同的类定义映射到此新的订单的函数，并引用

getOrderId

方法：

private Order wrap(SomeOrder obj) {
    return obj::getOrderId;
}

private Order wrap(AnotherOrder obj) {
    return obj::getOrderId;
}

一个叫它的例子：

private void test() {
    List<Order> orders = Arrays.asList(
        wrap(new SomeOrder()),
        wrap(new AnotherOrder())
    );
    sorter(orders);
}

private void test（）{
列表顺序=Arrays.asList(
包装（新的SomeOrder（）），
换行（新的另一个订单（））
);
分拣机（订单）；
}

围绕实现所需接口的实例创建一个

代理。代理仅使用相同的参数调用实例的方法

public class Proxied<T> implements InvocationHandler {
  private final T wrapped;

  public Proxied(T wrapped) {
    this.wrapped = Objects.requireNonNull(wrapped);
  }

  public T getWrapped() {
    return wrapped;
  }

  public <I> Class<I> proxy(Class<I> interfaceClass) {
    @SuppressWarnings("unchecked")
    Class<I> proxyClass = (Class<I>)  Proxy.getProxyClass(getClass().getClassLoader(), interfaceClass);
    return proxyClass;
  }

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    return method.invoke(wrapped, args);
  }
}

公共类代理实现调用处理程序{
私人最终T包装；
公共代理（T包装）{
this.wrapped=Objects.requirennull（wrapped）；
}
公共T getWrapped（）{
返回包装；
}
公共类代理（类接口类）{
@抑制警告（“未选中”）
类proxyClass=（类）Proxy.getProxyClass（getClass（）.getClassLoader（），interfaceClass）；
返回代理类；
}
@凌驾
公共对象调用（对象代理、方法、对象[]args）抛出Throwable{
return方法.invoke（wrapped，args）；
}
}