在 Java 中传递可选的匿名参数

Question

我有两个类 A 和 B。A 有一个方法，比如 foo，它可以有任意数量的任意类型的参数。该方法将这些参数传递给具有预定数量的预定类型参数的方法。

Class A{
   foo(<?> ... params){
      (new B()).bar(params);
   }
} 

Class B{
   bar(int a, int b){
       Log.v("The params passed are "+a+" and "+b);
   }
}

Class Caller{

    callingMethod(){
        (new A()).foo(1, 2);
    }
}

我知道编译器不允许我为 foo 写下的签名；我写它只是为了解释我想要实现的目标。

我不想在 B 类的 bar(int, int) 中进行任何转换。

Answer 1

您可以添加有限数量的参数，这些参数在可变参数之前是固定的。 这是在EnumSet中实现的

我已更改为 foo 方法以接受 3 个参数 E e1, E e2, E... params 确保我至少有 2 个参数来调用 bar(e1, e2) 方法。

<E extends Number> 确保您可以传递Number 的任何子类Integer 恰好是一个。

static class A {
    <E extends Number> void foo(E e1, E e2, E... params) {
        (new B<E>()).bar(e1, e2);
    }
}

static class B<E extends Number> {
    public void bar(E a, E b) {

    }
}

public static void main(String[] args) {

    A name = new A();
    name.foo(1, 2, 123);
}

Answer 2

你可以使用可变参数...

public static void foo(Object... parameters ){

}

Answer 3

Java 中的可变参数：

foo(Object... objs) {}

例子：

public static void main(String... args) {}

等价于

public static void main(String[] args) {}

注意：只要方法签名中没有剩余参数，就相当于使用数组。

Answer 4

正如其他人所建议的，您可以接受可变数量的Objects 作为函数参数。棘手的一点是打开包装以在B 上调用bar。我已经整理了一个示例，说明如何使用反射来做到这一点：

import java.lang.reflect.Method;

public class test {
  static class A {
    private final Class cl;
    A(Class cl) { 
      this.cl = cl;
    }
    void foo(Object ... params) throws Exception {
      Object obj = cl.newInstance();
      for (Method m : cl.getMethods()) {
        if (m.getName().equals("bar")) {
          try {
            m.invoke(obj, params);
            return;
          }
          catch(IllegalArgumentException ex) {} // try next overload
        }
      }
      throw new IllegalArgumentException();
    }
  }

  static class B {
    public void bar() {
      System.out.println("Got nothing");
    }

    public void bar(double a, double b) {
      System.out.println("Got doubles");
    }

    public void bar(int a, int b) {
      System.out.println("Got: " + a + " and " + b);
    }
  }

  public static void main(String argv[]) throws Exception {
    new A(B.class).foo(1,2);
    new A(B.class).foo();
    new B().bar(1,2);
    new A(B.class).foo("Hello");
  }
}

但是您会注意到，这里的重载解决方案远非完美，并且在调用 double,double 的 bar 中传递 1,2。要解决这个问题，您需要对Method 对象数组进行排序，使其与给定的每个对象的Class 最佳匹配，但据我所知，这远非微不足道。